IPython documentation

will

$ python setup.py install

--home
--prefix
$ python setup.py install --home $HOME/local

$ python setup.py --help

--home
--home
$ sudo pythonw setup.py install --install-scripts=/usr/local/bin

--install-scripts
[html]> ls
about.dat acks.html dist/ ext/ index.html lib/ modindex.html
stdabout.dat tut/ about.html api/ doc/ icons/ inst/ mac/ ref/ style.css

(defvar server-buffer-clients)
(when (and (fboundp 'server-start) (string-equal (getenv "TERM") 'xterm))
  (server-start)
  (defun fp-kill-server-with-buffer-routine ()
    (and server-buffer-clients (server-done)))
  (add-hook 'kill-buffer-hook 'fp-kill-server-with-buffer-routine))

[0;32mIn [[1;32m1[0;32m]: [0;00m

In [1]:

setenv PAGER less
setenv LESS -r

(require 'ipython)

(setq ansi-color-for-comint-mode t)

C-c |
%command 10-20 24 28

In [1]: %edit

IPython will make a temporary file named: /tmp/ipython_edit_yR-HCN.py

Editing... done. Executing edited code...

hello - this is a temporary file

Out[1]: "print 'hello - this is a temporary file'\n"

In [2]: edit -p

IPython will make a temporary file named: /tmp/ipython_edit_nA09Qk.py

Editing... done. Executing edited code...

hello - now I made some changes

Out[2]: "print 'hello - now I made some changes'\n"

In [3]: edit _1

IPython will make a temporary file named: /tmp/ipython_edit_gy6-zD.py

Editing... done. Executing edited code...

hello - this is a temporary file

IPython version control at work :)

Out[3]: "print 'hello - this is a temporary file'\nprint 'IPython version control at work :)'\n"

$ ipython [options] files

|
\
%copy \opt/foo/bar.txt \tmp
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

import IPython.ipapi

ip = IPython.ipapi.get()

def doimp(self, arg):

    ip = self.api

    ip.ex("import %s; reload(%s); from %s import *" % (

    arg,arg,arg)

    )

ip.expose_magic('impall', doimp)

Exit IPython without confirmation.

Toggle pretty printing on/off.

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.

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

In more detail, these values mean:

0 -> fully disabled

1 -> active, but do not apply if there are no arguments on the line.

In this mode, you get:

In [1]: callable
Out[1]: <built-in function callable>

In [2]: callable 'hello'
------> callable('hello')
Out[2]: False

2 -> Active always.  Even if no arguments are present, the callable
object is called:

In [4]: callable
------> callable()

Note that even with autocall off, you can still use '/' at the start of
a line to treat the first argument on the command line as a function
and add parentheses to it:

In [8]: /str 43
------> str(43)
Out[8]: '43'

Toggle autoindent on/off (if available).

Make magic functions callable without having to type the initial %.

Without argumentsl toggles on/off (when off, you must call it as
%automagic, of course).  With arguments it sets the value, and you can
use any of (case insensitive):

 - on,1,True: to activate

 - off,0,False: to deactivate.

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.

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

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.

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. You can also
do 'cd -<tab>' to see directory history conveniently.

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.)
      'cd -b <tab>' allows you to tab-complete bookmark names.

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

     Clear various data (e.g. stored history data)

%clear out - clear output history
%clear in  - clear input history
%clear shadow_compress - Compresses shadow history (to speed up ipython)
%clear shadow_nuke - permanently erase all entries in shadow history
%clear dhist - clear dir history

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.

Switch color scheme for prompts, info system and exception handlers.

Currently implemented schemes: NoColor, Linux, LightBG.

Color scheme names are not case-sensitive.

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. '>' and '+' characters at the beginning of a line are
ignored, to allow pasting directly from e-mails or diff files. 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).

Activate the interactive debugger in post-mortem mode.

If an exception has just occurred, this lets you inspect its stack
frames interactively.  Note that this will always work only on the last
traceback that occurred, so you must call this quickly after an
exception that you wish to inspect has fired, because if another one
occurs, it clobbers the previous one.

If you want IPython to automatically do this on every exception, see
the %pdb magic for more details.

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

Note that most of time, you should view directory history by entering
cd -<TAB>.

Return the current directory stack.

Toggle doctest mode on and off.

This mode allows you to toggle the prompt behavior between normal
IPython prompts and ones that are as similar to the default IPython
interpreter as possible.

It also supports the pasting of code snippets that have leading '>>>'
and '...' prompts in them.  This means that you can paste doctests from
files or docstrings (even if they have leading whitespace), and the
code will execute correctly.  You can then use '%history -tn' to see
the translated history without line numbers; this will give you the
input after removal of all the leading prompts and whitespace, which
can be pasted back into an editor.

With these features, you can switch into this mode easily whenever you
need to do testing and changes to doctests, without having to leave
your existing IPython session.

Alias to %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.

List environment variables.

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.

Alternate name for %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.

  -t: (default) print the 'translated' history, as IPython understands it.
  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 native
  history instead of the user-entered version: '%cd /' will be seen as
  '_ip.magic("%cd /")' instead of '%cd /'.

  -r: print the 'raw' history, i.e. the actual commands you typed.

  -g: treat the arg as a pattern to grep for in (full) history.
  This includes the "shadow history" (almost all commands ever written).
  Use '%hist -g' to show full shadow history (may be very long).
  In shadow history, every index nuwber starts with 0.

  -f FILENAME: instead of printing the output to the screen, redirect it to
   the given file.  The file is always overwritten, though IPython asks for
   confirmation first if it already exists.

Temporarily stop logging.

You must have previously started logging.

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.

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'#\[Out\]# ' '{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).

Print the status of the logging system.

Fully stop logging and close log file.

In order to start logging again, a new %logstart call needs to be made,
possibly (though not necessarily) with a new filename, mode and other
options.

List currently available magic functions.

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]

Print information about the magic function system.

        This program allows specifying filenames with "mglob" mechanism.
Supported syntax in globs (wilcard matching patterns)::

 *.cpp ?ellowo*
     - obvious. Differs from normal glob in that dirs are not included.
       Unix users might want to write this as: "*.cpp" "?ellowo*"
 rec:/usr/share=*.txt,*.doc
     - get all *.txt and *.doc under /usr/share,
       recursively
 rec:/usr/share
     - All files under /usr/share, recursively
 rec:*.py
     - All .py files under current working dir, recursively
 foo
     - File or dir foo
 !*.bak readme*
     - readme*, exclude files ending with .bak
 !.svn/ !.hg/ !*_Data/ rec:.
     - Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
       Trailing / is the key, \ does not work!
 dir:foo
     - the directory foo if it exists (not files in foo)
 dir:*
     - all directories in current folder
 foo.py bar.* !h* rec:*.py
     - Obvious. !h* exclusion only applies for rec:*.py.
       foo.py is *not* included twice.
 @filelist.txt
     - All files listed in 'filelist.txt' file, on separate lines.

Pretty print the object and display it through a pager.

%page [options] OBJECT

If no object is given, use _ (last output).

Options:

  -r: page str(object), don't pretty-print it.

Control the automatic 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.

The initial state of this feature is set in your ipythonrc
configuration file (the variable is called 'pdb').

If you want to just activate the debugger AFTER an exception has fired,
without having to type '%pdb on' and rerunning your code, you can use
the %debug magic.

Print the definition header for any callable object.

If the object is a class, print the constructor information.

Print the docstring for an object.

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

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.

Provide detailed information about an object.

'%pinfo object' is just a synonym for object? or ?object.

Change to directory popped off the top of the stack.

Print your currently active IPyhton profile.

 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.

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

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

Print (or run through pager) the source code for an object.

Place the current dir on stack and change directory.

Usage:\
  %pushd ['dirname']

Return the current working directory path.

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.

Show a quick reference sheet

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

Repeat previous input.

Note: Consider using the more powerfull %rep instead!

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.

     Add executables in all specified dirs to alias table

Usage:

%rehashdir c:/bin;c:/tools
  - Add all executables under c:/bin and c:/tools to alias table, in
  order to make them directly executable from any directory.

  Without arguments, add all executables in current directory.

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

This function also resets the root module cache of module completer,
used on slow filesystems.

     Repeat a command, or get command to input line for editing

- %rep (no arguments):

Place a string version of last computation result (stored in the special '_'
variable) to the next input prompt. Allows you to create elaborate command
lines without using copy-paste::

    $ l = ["hei", "vaan"]
    $ "".join(l)
    ==> heivaan
    $ %rep
    $ heivaan_ <== cursor blinking

%rep 45

Place history line 45 to next input prompt. Use %hist to find out the
number.

%rep 1-4 6-7 3

Repeat the specified lines immediately. Input slice syntax is the same as
in %macro and %save.

%rep foo

Place the most recent line that has the substring "foo" to next input.
(e.g. 'svn ci -m foobar').

Resets the namespace by removing all names defined by the user.

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

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
(except for sharing global objects such as previously imported
modules). 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.

There is one special usage for which the text above doesn't apply:
if the filename ends with .ipy, the file is run as ipython script,
just as if the commands were written on IPython prompt.

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

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.

    Lightweight persistence for python variables.

Example:

ville@badger[~]|1> A = ['hello',10,'world']\
ville@badger[~]|2> %store A\
ville@badger[~]|3> Exit

(IPython session is closed and started again...)

ville@badger:~$ ipython -p pysh\
ville@badger[~]|1> print A

['hello', 10, 'world']

Usage:

%store          - Show list of all variables and their current values\
%store <var>    - Store the *current* value of the variable to disk\
%store -d <var> - Remove the variable and its value from storage\
%store -z       - Remove all variables from storage\
%store -r       - Refresh all variables from store (delete current vals)\
%store foo >a.txt  - Store value of foo to new file a.txt\
%store foo >>a.txt - Append value of foo to file a.txt\

It should be noted that if you change the value of a variable, you
need to %store it again if you want to persist the new value.

Note also that the variables will need to be pickleable; most basic
python types can be safely %stored.

Also aliases can be %store'd across sessions.

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.

Set verbose printing of system calls.

If called without an argument, act as a toggle

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

  Note that the time needed by Python to compile the given expression
  will be reported if it is more than 0.1s.  In this example, the
  actual exponentiation is done by Python at compilation time, so while
  the expression can take a noticeable amount of time to compute, that
  time is purely due to the compilation:

  In [5]: time 3**9999;
  CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
  Wall time: 0.00 s

  In [6]: time 3**999999;
  CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
  Wall time: 0.00 s
  Compiler : 0.78 s

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.

Remove an alias

 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)

     %which <cmd> => search PATH for files matching cmd. Also scans aliases.

Traverses PATH and prints all files (not just executables!) that match the
pattern on command line. Probably more useful in finding stuff
interactively than 'which', which only prints the first matching item.

Also discovers and expands aliases, so you'll see what will be executed
when you call an alias.

Example:

[~]|62> %which d
d -> ls -F --color=auto
  == c:\cygwin\bin\ls.exe
c:\cygwin\bin\d.exe

[~]|64> %which diff*
diff3 -> diff3
  == c:\cygwin\bin\diff3.exe
diff -> diff
  == c:\cygwin\bin\diff.exe
c:\cygwin\bin\diff.exe
c:\cygwin\bin\diff3.exe

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.

Return a sorted list of all interactive variables.

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

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

Switch modes for the exception handlers.

Valid modes: Plain, Context and Verbose.

If called without arguments, acts as a toggle.

$if Python
"\M-i": "    "
"\M-u": "\d\d\d\d"
$endif

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

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

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

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

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'

cd -<TAB
>>> callable_ob arg1, arg2, arg3

-> callable_ob(arg1, arg2, arg3)

>>> /globals # becomes 'globals()'

>>> print /globals # syntax error

In [1]: zip (1,2,3),(4,5,6) # won't 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)]

In [18]: callable list
----> callable (list)

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

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

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

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

from <mod> import *
# -*- Mode: Shell-Script -*-  Not really, but shows comments correctly
# $Id: ipythonrc 2156 2007-03-19 02:32:19Z fperez $

#***************************************************************************
#
# Configuration file for IPython -- ipythonrc format
#
# ===========================================================
# Deprecation note: you should look into modifying ipy_user_conf.py (located
# in ~/.ipython or ~/_ipython, depending on your platform) instead, it's a
# more flexible and robust (and better supported!) configuration
# method.
# ===========================================================
#
# The format of this file is simply one of 'key value' lines.
# Lines containing only whitespace at the beginning and then a # are ignored
# as comments. But comments can NOT be put on lines with data.

# The meaning and use of each key are explained below.

#---------------------------------------------------------------------------
# Section: included files

# Put one or more *config* files (with the syntax of this file) you want to
# include. For keys with a unique value the outermost file has precedence. For
# keys with multiple values, they all get assembled into a list which then
# gets loaded by IPython.

# In this file, all lists of things should simply be space-separated.

# This allows you to build hierarchies of files which recursively load
# lower-level services. If this is your main ~/.ipython/ipythonrc file, you
# should only keep here basic things you always want available. Then you can
# include it in every other special-purpose config file you create.
include

#---------------------------------------------------------------------------
# Section: startup setup

# These are mostly things which parallel a command line option of the same
# name.

# Keys in this section should only appear once. If any key from this section
# is encountered more than once, the last value remains, all earlier ones get
# discarded.

# Automatic calling of callable objects.  If set to 1 or 2, callable objects
# are automatically called when invoked at the command line, even if you don't
# type parentheses.  IPython adds the parentheses for you.  For example:

#In [1]: str 45
#------> str(45)
#Out[1]: '45'

# IPython reprints your line with '---->' indicating that it added
# parentheses.  While this option is very convenient for interactive use, it
# may occasionally cause problems with objects which have side-effects if
# called unexpectedly.

# The valid values for autocall are:

# autocall 0 -> disabled (you can toggle it at runtime with the %autocall magic)

# autocall 1 -> active, but do not apply if there are no arguments on the line.

# In this mode, you get:

#In [1]: callable
#Out[1]: <built-in function callable>

#In [2]: callable 'hello'
#------> callable('hello')
#Out[2]: False

# 2 -> Active always.  Even if no arguments are present, the callable object
# is called:

#In [4]: callable
#------> callable()

# Note that even with autocall off, you can still use '/' at the start of a
# line to treat the first argument on the command line as a function and add
# parentheses to it:

#In [8]: /str 43
#------> str(43)
#Out[8]: '43'

autocall 1

# Auto-edit syntax errors.  When you use the %edit magic in ipython to edit
# source code (see the 'editor' variable below), it is possible that you save
# a file with syntax errors in it.  If this variable is true, IPython will ask
# you whether to re-open the editor immediately to correct such an error.

autoedit_syntax 0

# Auto-indent. 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 indent/unindenting more
# convenient (M-i indents, M-u unindents):

#  $if Python
#  "\M-i": "    "
#  "\M-u": "\d\d\d\d"
#  $endif

# The feature is potentially a bit dangerous, because it can cause problems
# with pasting of indented code (the pasted code gets re-indented on each
# line).  But it's a huge time-saver when working interactively.  The magic
# function %autoindent allows you to toggle it on/off at runtime.

autoindent 1

# Auto-magic. This gives you access to all the magic functions without having
# to prepend them with an % sign. If you define a variable with the same name
# as a magic function (say who=1), you will need to access the magic function
# with % (%who in this example). However, if later you delete your variable
# (del who), you'll recover the automagic calling form.

# Considering that many magic functions provide a lot of shell-like
# functionality, automagic gives you something close to a full Python+system
# shell environment (and you can extend it further if you want).

automagic 1

# Size of the output cache. After this many entries are stored, the cache will
# get flushed. Depending on the size of your intermediate calculations, you
# may have memory problems if you make it too big, since keeping things in the
# cache prevents Python from reclaiming the memory for old results. Experiment
# with a value that works well for you.

# If you choose cache_size 0 IPython will revert to python's regular >>>
# unnumbered prompt. You will still have _, __ and ___ for your last three
# results, but that will be it.  No dynamic _1, _2, etc. will be created. If
# you are running on a slow machine or with very limited memory, this may
# help.

cache_size 1000

# Classic mode: Setting 'classic 1' you lose many of IPython niceties,
# but that's your choice! Classic 1 -> same as IPython -classic.
# Note that this is _not_ the normal python interpreter, it's simply
# IPython emulating most of the classic interpreter's behavior.
classic 0

# colors - Coloring option for prompts and traceback printouts.

# Currently available schemes: NoColor, Linux, LightBG.

# This option allows coloring the prompts and traceback printouts. This
# requires a terminal which can properly handle color escape sequences. If you
# are having problems with this, use the NoColor scheme (uses no color escapes
# at all).

# The Linux option works well in linux console type environments: dark
# background with light fonts.

# LightBG is similar to Linux but swaps dark/light colors to be more readable
# in light background terminals.

# keep uncommented only the one you want:
colors Linux
#colors LightBG
#colors NoColor

########################
# Note to Windows users
#
# Color and readline support is avaialble to Windows users via Gary Bishop's
# readline library.  You can find Gary's tools at
# http://sourceforge.net/projects/uncpythontools.
# Note that his readline module requires in turn the ctypes library, available
# at http://starship.python.net/crew/theller/ctypes.
########################

# color_info: IPython can display information about objects via a set of
# functions, and optionally can use colors for this, syntax highlighting
# source code and various other elements. This information is passed through a
# pager (it defaults to 'less' if $PAGER is not set).

# If your pager has problems, try to setting it to properly handle escapes
# (see the less manpage for detail), or disable this option.  The magic
# function %color_info allows you to toggle this interactively for testing.

color_info 1

# confirm_exit: set to 1 if you want IPython to confirm when you try to exit
# with an EOF (Control-d in Unix, Control-Z/Enter in Windows). Note that using
# the magic functions %Exit or %Quit you can force a direct exit, bypassing
# any confirmation.

confirm_exit 1

# Use deep_reload() as a substitute for reload() by default. deep_reload() is
# still available as dreload() and appears as a builtin.

deep_reload 0

# Which editor to use with the %edit command. If you leave this at 0, IPython
# will honor your EDITOR environment variable. Since this editor is invoked on
# the fly by ipython and is meant for editing small code snippets, you may
# want to use a small, lightweight editor here.

# For Emacs users, setting up your Emacs server properly as described in the
# manual is a good idea. An alternative is to use jed, a very light editor
# with much of the feel of Emacs (though not as powerful for heavy-duty work).

editor 0

# log 1 -> same as ipython -log. This automatically logs to ./ipython.log
log 0

# Same as ipython -Logfile YourLogfileName.
# Don't use with log 1 (use one or the other)
logfile ''

# banner 0 -> same as ipython -nobanner
banner 1

# messages 0 -> same as ipython -nomessages
messages 1

# Automatically call the pdb debugger after every uncaught exception. If you
# are used to debugging using pdb, this puts you automatically inside of it
# after any call (either in IPython or in code called by it) which triggers an
# exception which goes uncaught.
pdb 0

# Enable the pprint module for printing. pprint tends to give a more readable
# display (than print) for complex nested data structures.
pprint 1

# Prompt strings

# Most bash-like escapes can be used to customize IPython's prompts, as well as
# a few additional ones which are IPython-specific.  All valid prompt escapes
# are described in detail in the Customization section of the IPython HTML/PDF
# manual.

# Use \# to represent the current prompt number, and quote them to protect
# spaces.
prompt_in1 'In [\#]: '

# \D is replaced by as many dots as there are digits in the
# current value of \#.
prompt_in2 '   .\D.: '

prompt_out 'Out[\#]: '

# Select whether to left-pad the output prompts to match the length of the
# input ones.  This allows you for example to use a simple '>' as an output
# prompt, and yet have the output line up with the input.  If set to false,
# the output prompts will be unpadded (flush left).
prompts_pad_left 1

# Pylab support: when ipython is started with the -pylab switch, by default it
# executes 'from matplotlib.pylab import *'.  Set this variable to false if you
# want to disable this behavior.

# For details on pylab, see the matplotlib website:
# http://matplotlib.sf.net
pylab_import_all 1

# quick 1 -> same as ipython -quick
quick 0

# Use the readline library (1) or not (0). Most users will want this on, but
# if you experience strange problems with line management (mainly when using
# IPython inside Emacs buffers) you may try disabling it. Not having it on
# prevents you from getting command history with the arrow keys, searching and
# name completion using TAB.

readline 1

# Screen Length: number of lines of your screen. This is used to control
# printing of very long strings. Strings longer than this number of lines will
# be paged with the less command instead of directly printed.

# The default value for this is 0, which means IPython will auto-detect your
# screen size every time it needs to print. If for some reason this isn't
# working well (it needs curses support), specify it yourself. Otherwise don't
# change the default.

screen_length 0

# Prompt separators for input and output.
# Use \n for newline explicitly, without quotes.
# Use 0 (like at the cmd line) to turn off a given separator.

# The structure of prompt printing is:
# (SeparateIn)Input....
# (SeparateOut)Output...
# (SeparateOut2),   # that is, no newline is printed after Out2
# By choosing these you can organize your output any way you want.

separate_in \n
separate_out 0
separate_out2 0

# 'nosep 1' is a shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'.
# Simply removes all input/output separators, overriding the choices above.
nosep 0

# Wildcard searches - IPython has a system for searching names using
# shell-like wildcards; type %psearch? for details.  This variables sets
# whether by default such searches should be case sensitive or not.  You can
# always override the default at the system command line or the IPython
# prompt.

wildcards_case_sensitive 1

# Object information: at what level of detail to display the string form of an
# object.  If set to 0, ipython will compute the string form of any object X,
# by calling str(X), when X? is typed.  If set to 1, str(X) will only be
# computed when X?? is given, and if set to 2 or higher, it will never be
# computed (there is no X??? level of detail).  This is mostly of use to
# people who frequently manipulate objects whose string representation is
# extremely expensive to compute.

object_info_string_level 0

# xmode - Exception reporting mode.

# Valid modes: Plain, Context and Verbose.

# Plain: similar to python's normal traceback printing.

# Context: prints 5 lines of context source code around each line in the
# traceback.

# Verbose: similar to Context, but additionally prints the variables currently
# visible where the exception happened (shortening their strings if too
# long). This can potentially be very slow, if you happen to have a huge data
# structure whose string representation is complex to compute. Your computer
# may appear to freeze for a while with cpu usage at 100%. If this occurs, you
# can cancel the traceback with Ctrl-C (maybe hitting it more than once).

#xmode Plain
xmode Context
#xmode Verbose

# multi_line_specials: if true, allow magics, aliases and shell escapes (via
# !cmd) to be used in multi-line input (like for loops).  For example, if you
# have this active, the following is valid in IPython:
#
#In [17]: for i in range(3):
#   ....:     mkdir $i
#   ....:     !touch $i/hello
#   ....:     ls -l $i

multi_line_specials 1

# System calls: When IPython makes system calls (e.g. via special syntax like
# !cmd or !!cmd, or magics like %sc or %sx), it can print the command it is
# executing to standard output, prefixed by a header string.

system_header "IPython system call: "

system_verbose 1

# wxversion: request a specific wxPython version (used for -wthread)

# Set this to the value of wxPython you want to use, but note that this
# feature requires you to have the wxversion Python module to work.  If you
# don't have the wxversion module (try 'import wxversion' at the prompt to
# check) or simply want to leave the system to pick up the default, leave this
# variable at 0.

wxversion 0

#---------------------------------------------------------------------------
# Section: Readline configuration (readline is not available for MS-Windows)

# This is done via the following options:

# (i) 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.

# The TAB key can be used to complete names at the command line in one of two
# ways: 'complete' and 'menu-complete'. The difference is that 'complete' only
# completes as much as possible while 'menu-complete' cycles through all
# possible completions. Leave the one you prefer uncommented.

readline_parse_and_bind tab: complete
#readline_parse_and_bind tab: menu-complete

# This binds Control-l to printing the list of all possible completions when
# there is more than one (what 'complete' does when hitting TAB twice, or at
# the first TAB if show-all-if-ambiguous is on)
readline_parse_and_bind "\C-l": possible-completions

# This forces readline to automatically print the above list when tab
# completion is set to 'complete'. You can still get this list manually by
# using the key bound to 'possible-completions' (Control-l by default) or by
# hitting TAB twice. Turning this on makes the printing happen at the first
# TAB.
readline_parse_and_bind set show-all-if-ambiguous on

# If you have TAB set to complete names, you can rebind any key (Control-o by
# default) to insert a true TAB character.
readline_parse_and_bind "\C-o": tab-insert

# These commands allow you to indent/unindent easily, with the 4-space
# convention of the Python coding standards.  Since IPython's internal
# auto-indent system also uses 4 spaces, you should not change the number of
# spaces in the code below.
readline_parse_and_bind "\M-i": "    "
readline_parse_and_bind "\M-o": "\d\d\d\d"
readline_parse_and_bind "\M-I": "\d\d\d\d"

# Bindings for incremental searches in the history. These searches use the
# string typed so far on the command line and search anything in the previous
# input history containing them.
readline_parse_and_bind "\C-r": reverse-search-history
readline_parse_and_bind "\C-s": forward-search-history

# Bindings for completing the current line in the history of previous
# commands. This allows you to recall any previous command by typing its first
# few letters and hitting Control-p, bypassing all intermediate commands which
# may be in the history (much faster than hitting up-arrow 50 times!)
readline_parse_and_bind "\C-p": history-search-backward
readline_parse_and_bind "\C-n": history-search-forward

# I also like to have the same functionality on the plain arrow keys. If you'd
# rather have the arrows use all the history (and not just match what you've
# typed so far), comment out or delete the next two lines.
readline_parse_and_bind "\e[A": history-search-backward
readline_parse_and_bind "\e[B": history-search-forward

# These are typically on by default under *nix, but not win32.
readline_parse_and_bind "\C-k": kill-line
readline_parse_and_bind "\C-u": unix-line-discard

# (ii) 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.

readline_remove_delims -/~

# (iii) readline_merge_completions: whether to merge the result of all
# possible completions or not.  If true, IPython will complete filenames,
# python names and aliases and return all possible completions.  If you set it
# to false, each completer is used at a time, and only if it doesn't return
# any completions is the next one used.

# The default order is: [python_matches, file_matches, alias_matches]

readline_merge_completions 1

# (iv) readline_omit__names: normally hitting <tab> after a '.' in a name
# will complete all attributes of an object, including all the special methods
# whose names start with single or double underscores (like __getitem__ or
# __class__).

# This variable allows you to control this completion behavior:

# readline_omit__names 1 -> completion will omit showing any names starting
# with two __, but it will still show names starting with one _.

# readline_omit__names 2 -> completion will omit all names beginning with one
# _ (which obviously means filtering out the double __ ones).

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

readline_omit__names 0

#---------------------------------------------------------------------------
# Section: modules to be loaded with 'import ...'

# List, separated by spaces, the names of the modules you want to import

# Example:
# import_mod sys os
# will produce internally the statements
# import sys
# import os

# Each import is executed in its own try/except block, so if one module
# fails to load the others will still be ok.

import_mod

#---------------------------------------------------------------------------
# Section: modules to import some functions from: 'from ... import ...'

# List, one per line, the modules for which you want only to import some
# functions. Give the module name first and then the name of functions to be
# imported from that module.

# Example:

# import_some IPython.genutils timing timings
# will produce internally the statement
# from IPython.genutils import timing, timings

# timing() and timings() are two IPython utilities for timing the execution of
# your own functions, which you may find useful.  Just commment out the above
# line if you want to test them.

# If you have more than one modules_some line, each gets its own try/except
# block (like modules, see above).

import_some

#---------------------------------------------------------------------------
# Section: modules to import all from : 'from ... import *'

# List (same syntax as import_mod above) those modules for which you want to
# import all functions. Remember, this is a potentially dangerous thing to do,
# since it is very easy to overwrite names of things you need. Use with
# caution.

# Example:
# import_all sys os
# will produce internally the statements
# from sys import *
# from os import *

# As before, each will be called in a separate try/except block.

import_all

#---------------------------------------------------------------------------
# Section: Python code to execute.

# Put here code to be explicitly executed (keep it simple!)
# Put one line of python code per line. All whitespace is removed (this is a
# feature, not a bug), so don't get fancy building loops here.
# This is just for quick convenient creation of things you want available.

# Example:
# execute x = 1
# execute print 'hello world'; y = z = 'a'
# will produce internally
# x = 1
# print 'hello world'; y = z = 'a'
# and each *line* (not each statement, we don't do python syntax parsing) is
# executed in its own try/except block.

execute

# Note for the adventurous: you can use this to define your own names for the
# magic functions, by playing some namespace tricks:

# execute __IPYTHON__.magic_pf = __IPYTHON__.magic_profile

# defines %pf as a new name for %profile.

#---------------------------------------------------------------------------
# Section: Pyhton files to load and execute.

# Put here the full names of files you want executed with execfile(file).  If
# you want complicated initialization, just write whatever you want in a
# regular python file and load it from here.

# Filenames defined here (which *must* include the extension) are searched for
# through all of sys.path. Since IPython adds your .ipython directory to
# sys.path, they can also be placed in your .ipython dir and will be
# found. Otherwise (if you want to execute things not in .ipyton nor in
# sys.path) give a full path (you can use ~, it gets expanded)

# Example:
# execfile file1.py ~/file2.py
# will generate
# execfile('file1.py')
# execfile('_path_to_your_home/file2.py')

# As before, each file gets its own try/except block.

execfile

# If you are feeling adventurous, you can even add functionality to IPython
# through here. IPython works through a global variable called __ip which
# exists at the time when these files are read. If you know what you are doing
# (read the source) you can add functions to __ip in files loaded here.

# The file example-magic.py contains a simple but correct example. Try it:

# execfile example-magic.py

# Look at the examples in IPython/iplib.py for more details on how these magic
# functions need to process their arguments.

#---------------------------------------------------------------------------
# Section: aliases for system shell commands

# Here you can define your own names for system commands. The syntax is
# similar to that of the builtin %alias function:

# alias alias_name command_string

# The resulting aliases are auto-generated magic functions (hence usable as
# %alias_name)

# For example:

# alias myls ls -la

# will define 'myls' as an alias for executing the system command 'ls -la'.
# This allows you to customize IPython's environment to have the same aliases
# you are accustomed to from your own shell.

# You can also define aliases with parameters using %s specifiers (one per
# parameter):

# alias parts echo first %s second %s

# will give you in IPython:
# >>> %parts A B
# first A second B

# Use one 'alias' statement per alias you wish to define.

# alias

#************************* end of file <ipythonrc> ************************

# Most of your config files and extensions will probably start
# with this import

import IPython.ipapi
ip = IPython.ipapi.get()

# You probably want to uncomment this if you did %upgrade -nolegacy
# import ipy_defaults

import os

def main():

    #ip.dbg.debugmode = True
    ip.dbg.debug_stack()

    # uncomment if you want to get ipython -p sh behaviour
    # without having to use command line switches
    import ipy_profile_sh
    import jobctrl

    # Configure your favourite editor?
    # Good idea e.g. for %edit os.path.isfile

    #import ipy_editors

    # Choose one of these:

    #ipy_editors.scite()
    #ipy_editors.scite('c:/opt/scite/scite.exe')
    #ipy_editors.komodo()
    #ipy_editors.idle()
    # ... or many others, try 'ipy_editors??' after import to see them

    # Or roll your own:
    #ipy_editors.install_editor("c:/opt/jed +$line $file")

    o = ip.options
    # An example on how to set options
    #o.autocall = 1
    o.system_verbose = 0

    #import_all("os sys")
    #execf('~/_ipython/ns.py')

    # -- prompt
    # A different, more compact set of prompts from the default ones, that
    # always show your current location in the filesystem:

    #o.prompt_in1 = r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Normal\n\C_Green|\#>'
    #o.prompt_in2 = r'.\D: '
    #o.prompt_out = r'[\#] '

    # Try one of these color settings if you can't read the text easily
    # autoexec is a list of IPython commands to execute on startup
    #o.autoexec.append('%colors LightBG')
    #o.autoexec.append('%colors NoColor')
    o.autoexec.append('%colors Linux')

# some config helper functions you can use
def import_all(modules):
    """ Usage: import_all("os sys") """
    for m in modules.split():
        ip.ex("from %s import *" % m)

def execf(fname):
    """ Execute a file in user namespace """
    ip.ex('execfile("%s")' % os.path.expanduser(fname))

main()

\#
    the prompt/history count number. This escape is automatically
    wrapped in the coloring codes for the currently active color scheme.
\N
    the 'naked' prompt/history count number: this is just the number
    itself, without any coloring applied to it. This lets you produce
    numbered prompts with your own colors.
\D
    the prompt/history count, with the actual digits replaced by dots.
    Used mainly in continuation prompts (prompt_in2)
\w
    the current working directory
\W
    the basename of current working directory
\Xn
    where $n=0\ldots5.$ The current working directory, with $HOME
    replaced by ~, and filtered out to contain only $n$ path elements
\Yn
    Similar to \Xn, but with the $n+1$ element included if it is ~ (this
    is similar to the behavior of the %cn escapes in tcsh)
\u
    the username of the current user
\$
    if the effective UID is 0, a #, otherwise a $
\h
    the hostname up to the first '.'
\H
    the hostname
\n
    a newline
\r
    a carriage return
\v
    IPython version string

prompt_in1 'In [\#]:'
prompt_in2 '   .\D.:'
prompt_out 'Out[\#]:'

In [1]: 1+2
Out[1]: 3

In [2]: for i in (1,2,3):
   ...:    print i,
   ...:
1 2 3

#prompt_in1 '\C_Red\u\C_Blue[\C_Cyan\Y1\C_Blue]\C_LightGreen\#>'
prompt_in2 ' ..\D>'
prompt_out '<\#>'

fperez[~/ipython]1> 1+2
                <1> 3
fperez[~/ipython]2> for i in (1,2,3):
               ...>     print i,
               ...>
1 2 3

import IPython
IPython.Shell.IPShell().mainloop(sys_exit=1)

from IPython.Shell import IPShellEmbed

ipshell = IPShellEmbed()

ipshell() # this call anywhere in your program will start IPython

#!/usr/bin/env python

"""An example of how to embed an IPython shell into a running program.

Please see the documentation in the IPython.Shell module for more details.

The accompanying file example-embed-short.py has quick code fragments for
embedding which you can cut and paste in your code once you understand how
things work.

The code in this file is deliberately extra-verbose, meant for learning."""

# The basics to get you going:

# IPython sets the __IPYTHON__ variable so you can know if you have nested
# copies running.

# Try running this code both at the command line and from inside IPython (with
# %run example-embed.py)
try:
    __IPYTHON__
except NameError:
    nested = 0
    args = ['']
else:
    print "Running nested copies of IPython."
    print "The prompts for the nested copy have been modified"
    nested = 1
    # what the embedded instance will see as sys.argv:
    args = ['-pi1','In <\\#>: ','-pi2','   .\\D.: ',
            '-po','Out<\\#>: ','-nosep']

# First import the embeddable shell class
from IPython.Shell import IPShellEmbed

# Now create an instance of the embeddable shell. The first argument is a
# string with options exactly as you would type them if you were starting
# IPython at the system command line. Any parameters you want to define for
# configuration can thus be specified here.
ipshell = IPShellEmbed(args,
                       banner = 'Dropping into IPython',
                       exit_msg = 'Leaving Interpreter, back to program.')

# Make a second instance, you can have as many as you want.
if nested:
    args[1] = 'In2<\\#>'
else:
    args = ['-pi1','In2<\\#>: ','-pi2','   .\\D.: ',
            '-po','Out<\\#>: ','-nosep']
ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.')

print '\nHello. This is printed from the main controller program.\n'

# You can then call ipshell() anywhere you need it (with an optional
# message):
ipshell('***Called from top level. '
        'Hit Ctrl-D to exit interpreter and continue program.\n'
        'Note that if you use %kill_embedded, you can fully deactivate\n'
        'This embedded instance so it will never turn on again')

print '\nBack in caller program, moving along...\n'

#---------------------------------------------------------------------------
# More details:

# IPShellEmbed instances don't print the standard system banner and
# messages. The IPython banner (which actually may contain initialization
# messages) is available as <instance>.IP.BANNER in case you want it.

# IPShellEmbed instances print the following information everytime they
# start:

# - A global startup banner.

# - A call-specific header string, which you can use to indicate where in the
# execution flow the shell is starting.

# They also print an exit message every time they exit.

# Both the startup banner and the exit message default to None, and can be set
# either at the instance constructor or at any other time with the
# set_banner() and set_exit_msg() methods.

# The shell instance can be also put in 'dummy' mode globally or on a per-call
# basis. This gives you fine control for debugging without having to change
# code all over the place.

# The code below illustrates all this.

# This is how the global banner and exit_msg can be reset at any point
ipshell.set_banner('Entering interpreter - New Banner')
ipshell.set_exit_msg('Leaving interpreter - New exit_msg')

def foo(m):
    s = 'spam'
    ipshell('***In foo(). Try @whos, or print s or m:')
    print 'foo says m = ',m

def bar(n):
    s = 'eggs'
    ipshell('***In bar(). Try @whos, or print s or n:')
    print 'bar says n = ',n

# Some calls to the above functions which will trigger IPython:
print 'Main program calling foo("eggs")\n'
foo('eggs')

# The shell can be put in 'dummy' mode where calls to it silently return. This
# allows you, for example, to globally turn off debugging for a program with a
# single call.
ipshell.set_dummy_mode(1)
print '\nTrying to call IPython which is now "dummy":'
ipshell()
print 'Nothing happened...'
# The global 'dummy' mode can still be overridden for a single call
print '\nOverriding dummy mode manually:'
ipshell(dummy=0)

# Reactivate the IPython shell
ipshell.set_dummy_mode(0)

print 'You can even have multiple embedded instances:'
ipshell2()

print '\nMain program calling bar("spam")\n'
bar('spam')

print 'Main program finished. Bye!'

#********************** End of file <example-embed.py> ***********************

"""Quick code snippets for embedding IPython into other programs.

See example-embed.py for full details, this file has the bare minimum code for
cut and paste use once you understand how to use the system."""

#---------------------------------------------------------------------------
# This code loads IPython but modifies a few things if it detects it's running
# embedded in another IPython session (helps avoid confusion)

try:
    __IPYTHON__
except NameError:
    argv = ['']
    banner = exit_msg = ''
else:
    # Command-line options for IPython (a list like sys.argv)
    argv = ['-pi1','In <\\#>:','-pi2','   .\\D.:','-po','Out<\\#>:']
    banner = '*** Nested interpreter ***'
    exit_msg = '*** Back in main IPython ***'

# First import the embeddable shell class
from IPython.Shell import IPShellEmbed
# Now create the IPython shell instance. Put ipshell() anywhere in your code
# where you want it to open.
ipshell = IPShellEmbed(argv,banner=banner,exit_msg=exit_msg)

#---------------------------------------------------------------------------
# This code will load an embeddable IPython shell always with no changes for
# nested embededings.

from IPython.Shell import IPShellEmbed
ipshell = IPShellEmbed()
# Now ipshell() will open IPython anywhere in the code.

#---------------------------------------------------------------------------
# This code loads an embeddable shell only if NOT running inside
# IPython. Inside IPython, the embeddable shell variable ipshell is just a
# dummy function.

try:
    __IPYTHON__
except NameError:
    from IPython.Shell import IPShellEmbed
    ipshell = IPShellEmbed()
    # Now ipshell() will open IPython anywhere in the code
else:
    # Define a dummy ipshell() so the same code doesn't crash inside an
    # interactive IPython
    def ipshell(): pass

#******************* End of file <example-embed-short.py> ********************

import sys,IPython.ultraTB
sys.excepthook = IPython.ultraTB.FormattedTB(mode='Verbose',
color_scheme='Linux', call_pdb=1)

IPython profile: tutorial

*** Pasting of code with ">>>" or "..." has been enabled.

In [1]: >>> def fib2(n): # return Fibonacci series up to n
   ...: ...     """Return a list containing the Fibonacci series up to
n."""
   ...: ...     result = []
   ...: ...     a, b = 0, 1
   ...: ...     while b < n:
   ...: ...         result.append(b)    # see below
   ...: ...         a, b = b, a+b
   ...: ...     return result
   ...:

In [2]: fib2(10)
Out[2]: [1, 1, 2, 3, 5, 8]

In [1]: v = PhysicalQuantity(3,'m/s')

import ipy_profile_sh
%env - Show all environment variables
%env VISUAL=jed  - set VISUAL to jed
%env PATH+=;/foo - append ;foo to PATH
%env PATH+=;/bar - also append ;bar to PATH
%env PATH-=/wbin; - prepend /wbin; to PATH
%env -d VISUAL   - forget VISUAL persistent val
%env -p          - print all persistent env modifications

[C:/ipython]|14> %which st
st -> start .
[C:/ipython]|15> %which d
d -> dir /w /og /on
[C:/ipython]|16> %which cp
cp -> cp
  == c:\bin\cp.exe
c:\bin\cp.exe

[~]|22> cd c:/opt/PuTTY/
[c:opt/PuTTY]|23> rehashdir .
             <23> ['pageant', 'plink', 'pscp', 'psftp', 'putty', 'puttygen', 'unins000']

[c:opt/PuTTY]|24> cd
[~]|25> putty

[~]|27> for a in _23:
   |..>     %store $a
   |..>
   |..>
Alias stored: pageant (0, 'c:\\opt\\PuTTY\\pageant.exe')
Alias stored: plink (0, 'c:\\opt\\PuTTY\\plink.exe')
Alias stored: pscp (0, 'c:\\opt\\PuTTY\\pscp.exe')
Alias stored: psftp (0, 'c:\\opt\\PuTTY\\psftp.exe')
...

[c:/ipython]|9> mglob *.py
[c:/ipython]|10> mglob *.py rec:*.txt
[c:/ipython]|19> workfiles = %mglob !.svn/ !.hg/ !*_Data/ !*.bak rec:.

o.prompt_in1= r'\C_LightBlue[\C_LightCyan\Y2\C_LightBlue]\C_Green|\#>'
o.prompt_in2= r'\C_Green|\C_LightGreen\D\C_Green>'

var = !cmd
[Q:doc/examples]|2> lines = !ls -l
 ==
['total 23',
 '-rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py',
 '-rw-rw-rw- 1 ville None 1927 Sep 30  2006 example-embed-short.py',
 '-rwxrwxrwx 1 ville None 4606 Sep  1 17:15 example-embed.py',
 '-rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py',
 '-rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py',
 '-rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py',
 '-rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc']

[Q:doc/examples]|3> lines
                <3> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:

0: total 23
1: -rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py
2: -rw-rw-rw- 1 ville None 1927 Sep 30  2006 example-embed-short.py
3: -rwxrwxrwx 1 ville None 4606 Sep  1 17:15 example-embed.py
4: -rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py
5: -rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py
6: -rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py
7: -rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc

[Q:doc/examples]|4> l2 = lines.grep('embed',prune=1)
[Q:doc/examples]|5> l2
                <5> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:

0: total 23
1: -rw-rw-rw- 1 ville None 1163 Sep 30  2006 example-demo.py
2: -rwxrwxrwx 1 ville None 1017 Sep 30  2006 example-gnuplot.py
3: -rwxrwxrwx 1 ville None  339 Jun 11 18:01 extension.py
4: -rwxrwxrwx 1 ville None  113 Dec 20  2006 seteditor.py
5: -rwxrwxrwx 1 ville None  245 Dec 12  2006 seteditor.pyc

[Q:doc/examples]|6> l2.fields(8,0)
                <6> SList (.p, .n, .l, .s, .grep(), .fields() available). Value:

0: total
1: example-demo.py -rw-rw-rw-
2: example-gnuplot.py -rwxrwxrwx
3: extension.py -rwxrwxrwx
4: seteditor.py -rwxrwxrwx
5: seteditor.pyc -rwxrwxrwx

[Q:doc/examples]|7> _.fields()
                <7>
[['total'],
 ['example-demo.py', '-rw-rw-rw-'],
 ['example-gnuplot.py', '-rwxrwxrwx'],
 ['extension.py', '-rwxrwxrwx'],
 ['seteditor.py', '-rwxrwxrwx'],
 ['seteditor.pyc', '-rwxrwxrwx']]

[Q:doc/examples]|13> files = l2.fields(8).s
[Q:doc/examples]|14> files
                <14> 'example-demo.py example-gnuplot.py extension.py seteditor.py seteditor.pyc'
[Q:doc/examples]|15> ls $files
example-demo.py  example-gnuplot.py  extension.py  seteditor.py  seteditor.pyc

[Q:doc/examples]|21> lines.append('hey')

[Q:/ipython]|28> out = !hg status
 ==
['M IPython\\Extensions\\ipy_kitcfg.py',
 'M IPython\\Extensions\\ipy_rehashdir.py',
...
 '? build\\lib\\IPython\\Debugger.py',
 '? build\\lib\\IPython\\Extensions\\InterpreterExec.py',
 '? build\\lib\\IPython\\Extensions\\InterpreterPasteInput.py',
...

[Q:/ipython]|35> junk = out.grep(r'^\?').fields(1)
[Q:/ipython]|36> junk
            <36> SList (.p, .n, .l, .s, .grep(), .fields() availab
...
10: build\bdist.win32\winexe\temp\_ctypes.py
11: build\bdist.win32\winexe\temp\_hashlib.py
12: build\bdist.win32\winexe\temp\_socket.py

print >> filehandle, ''hello world''

filehandle = open(filename,mode,0)

"""A simple interactive demo to illustrate the use of IPython's Demo class.

Any python script can be run as a demo, but that does little more than showing
it on-screen, syntax-highlighted in one shot.  If you add a little simple
markup, you can stop at specified intervals and return to the ipython prompt,
resuming execution later.
"""

print 'Hello, welcome to an interactive IPython demo.'
print 'Executing this block should require confirmation before proceeding,'
print 'unless auto_all has been set to true in the demo object'

# The mark below defines a block boundary, which is a point where IPython will
# stop execution and return to the interactive prompt.
# Note that in actual interactive execution,
# <demo> --- stop ---

x = 1
y = 2

# <demo> --- stop ---

# the mark below makes this block as silent
# <demo> silent

print 'This is a silent block, which gets executed but not printed.'

# <demo> --- stop ---
# <demo> auto
print 'This is an automatic block.'
print 'It is executed without asking for confirmation, but printed.'
z = x+y

print 'z=',x

# <demo> --- stop ---
# This is just another normal block.
print 'z is now:', z

print 'bye!'

from IPython.demo import Demo

mydemo = Demo('myscript.py')

mydemo

from IPython import demo

demo?

#!python
import IPython.ipapi
ip = IPython.ipapi.get()

[~\_ipython]|81> a = 10
[~\_ipython]|82> _ip.e
_ip.ev           _ip.ex           _ip.expose_magic
[~\_ipython]|82> _ip.ev('a+13')
            <82> 23

o = ip.options
o.autocall = 2
o.automagic = 1

ip.ev
ip.ex
# path module will be visible to the interactive session
ip.ex("from path import path" )

# define a handy function 'up' that changes the working directory

ip.ex('import os')
ip.ex("def up(): os.chdir('..')")

# _i2 has the input history entry #2, print its value in uppercase.
print ip.ev('_i2.upper()')

[~\_ipython]|84> tauno = 555
[~\_ipython]|85> _ip.user_ns['tauno']
            <85> 555

def doimp(self, arg):
    ip = self.api
    ip.ex("import %s; reload(%s); from %s import *" % (
    arg,arg,arg)
    )

ip.expose_magic('impall', doimp)

# go to a bookmark
ip.magic('%cd -b relfiles')

# execute 'ls -F' system command. Interchangeable with os.system('ls'), really.
ip.system('ls -F')

[ipython]|1> cat test.py
my_ns = dict(
    kissa = 15,
    koira = 16)
import IPython.ipapi
print "launching IPython instance"
IPython.ipapi.launch_new_instance(my_ns)
print "Exited IPython instance!"
print "New vals:",my_ns['kissa'], my_ns['koira']

Q:\ipython>python test.py
launching IPython instance
Py 2.5 (r25:51908, Sep 19 2006, 09:52:17) [MSC v.1310 32 bit (Intel)] IPy 0.7.3b3.r1975
[ipython]|1> kissa = 444
[ipython]|2> koira = 555
[ipython]|3> Exit
Exited IPython instance!
New vals: 444 555

[~]|7> _ip.IP.expand_aliases('np','myfile.py')
   <7> 'c:/opt/Notepad++/notepad++.exe myfile.py'
[~]|8>

import ipy_<TAB>
ipy_
[c:p/ipython_main]|190> import ipy_fsops
[c:p/ipython_main]|191> ipy_fsops?

...

Docstring:
    File system operations

Contains: Simple variants of normal unix shell commands (icp, imv, irm,
imkdir, igrep).

[c:p]|192> import ipy_traits_completer
[c:p]|193> ipy_traits_completer.activate()

IPython is released under a BSD-type license.

Copyright (c) 2001, 2002, 2003, 2004 Fernando Perez
<fperez@colorado.edu>.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

a. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.

b. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

c. Neither the name of the copyright holders nor the names of any
contributors to this software may be used to endorse or promote
products derived from this software without specific prior written
permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

`-nosep`	shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2 0'. Simply removes all input/output separators.
`-upgrade`	allows you to upgrade your IPYTHONDIR configuration when you install a new version of IPython. Since new versions may include new command line options or example files, this copies updated ipythonrc-type files. However, it backs up (with a .old extension) all files which it overwrites so that you can merge back any customizations you might have in your personal files. Note that you should probably use %upgrade instead, it's a safer alternative.
`-Version`	print version information and exit.

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages

IPython documentation

Indices and tables

Introduction

Overview

Main features

Portability and Python requirements

Location

Installation

Instant instructions

Mac OSX information

GUI problems

Readline problems

DarwinPorts

Windows instructions

Installation procedure

Upgrading

Manual installation under Win32

Upgrading from a previous version

Initial configuration of your environment

Access to the Python help system

Editor

Color

Input/Output prompts and exception tracebacks

Object details (types, docstrings, source code, etc.)

(X)Emacs configuration

Quick tips

Source code handling tips

Lightweight 'version control'

Effective logging

Command-line use

Special Threading Options

Regular Options

Interactive use

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

Customization

The ipythonrc approach

Sample ipythonrc file

ipy_user_conf.py

Fine-tuning your prompt

IPython profiles

IPython as your default Python environment

Embedding IPython

Using the Python debugger (pdb)

Running entire programs via pdb

Automatic invocation of pdb on exceptions

Extensions for syntax processing

Pasting of code starting with '>>> ' or '... '

Input of physical quantities with units

IPython as a system shell - the 'Sh' profile

Aliases

Directory management

Enabled extensions

envpersist

ipy_which

ipy_app_completers

ipy_rehashdir

mglob

Prompt customization