### Navigation

- index
- modules |
- next |
- previous |
- home|
- search|
- documentation »
- The IPython API »

# core.interactiveshell

## Module: `core.interactiveshell`

Inheritance diagram for `IPython.core.interactiveshell`:

Main IPython class.

## Classes

### `Bunch`

class `IPython.core.interactiveshell.``Bunch`

### `InteractiveShell`

class `IPython.core.interactiveshell.``InteractiveShell`(config=None, ipython_dir=None, profile_dir=None, user_module=None, user_ns=None, custom_exceptions=((), None))

  Bases: `IPython.config.configurable.SingletonConfigurable`, `IPython.core.magic.Magic`

  An enhanced, interactive shell for Python.

  `__init__`(config=None, ipython_dir=None, profile_dir=None, user_module=None, user_ns=None, custom_exceptions=((), None))
  `alias_manager`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `all_ns_refs`

    Get a list of references to all the namespace dictionaries in which IPython might store a user-created object.

    Note that this does not include the displayhook, which also caches objects from the output.

  `arg_err`(func)

    Print docstring if incorrect arguments were passed

  `ask_yes_no`(prompt, default=None)
  `atexit_operations`()

    This will be executed at the time of exit.

    Cleanup operations and saving of persistent data that is done unconditionally by IPython should be performed here.

    For things that may depend on startup flags or platform specifics (such as having readline or not), register a separate atexit function in the code that has the appropriate information, rather than trying to clutter

  `auto_rewrite_input`(cmd)

    Print to the screen the rewritten form of the user’s command.

    This shows visual feedback by rewriting input lines that cause automatic calling to kick in, like:

        /f x

    into:

        ------> f(x)

    after the user’s input prompt. This helps the user understand that the input line was transformed automatically by IPython.

  `autocall`

    An enum that whose value must be in a given sequence.

  `autoindent`

    A casting version of the boolean trait.

  `automagic`

    A casting version of the boolean trait.

  `builtin_trap`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `cache_main_mod`(ns, fname)

    Cache a main module’s namespace.

    When scripts are executed via %run, we must keep a reference to the namespace of their __main__ module (a FakeModule instance) around so that Python doesn’t clear it, rendering objects defined therein useless.

    This method keeps said reference in a private dict, keyed by the absolute path of the module object (which corresponds to the script path). This way, for multiple executions of the same script we only keep one copy of the namespace (the last one), thus preventing memory leaks from old references while allowing the objects from the last execution to be accessible.

    Note: we can not allow the actual FakeModule instances to be deleted, because of how Python tears down modules (it hard-sets all their references to None without regard for reference counts). This method must therefore make a copy of the given namespace, to allow the original module’s __dict__ to be cleared and reused.

    Parameters :

    ns : a namespace (a dict, typically)

    > fname : str

    >   Filename associated with the namespace.

    Examples

    In [10]: import IPython

    In [11]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)

    In [12]: IPython.__file__ in _ip._main_ns_cache Out[12]: True

  `cache_size`

    An integer trait.

    Longs that are unnecessary (<= sys.maxint) are cast to ints.

  `call_pdb`

    Control auto-activation of pdb at exceptions

  classmethod `class_config_section`()

    Get the config class config section

  classmethod `class_get_help`(inst=None)

    Get the help string for this class in ReST format.

    If inst is given, it’s current trait values will be used in place of class defaults.

  classmethod `class_get_trait_help`(trait, inst=None)

    Get the help string for a single trait.

    If inst is given, it’s current trait values will be used in place of the class default.

  classmethod `class_print_help`(inst=None)

    Get the help string for a single trait and print it.

  classmethod `class_trait_names`(**metadata)

    Get a list of all the names of this classes traits.

    This method is just like the `trait_names()` method, but is unbound.

  classmethod `class_traits`(**metadata)

    Get a list of all the traits of this class.

    This method is just like the `traits()` method, but is unbound.

    The TraitTypes returned don’t know anything about the values that the various HasTrait’s instances are holding.

    This follows the same algorithm as traits does and does not allow for any simple way of specifying merely that a metadata name exists, but has any value. This is because get_metadata returns None if a metadata key doesn’t exist.

  `cleanup`()
  classmethod `clear_instance`()

    unset _instance for this class and singleton parents.

  `clear_main_mod_cache`()

    Clear the cache of main modules.

    Mainly for use by utilities like %reset.

    Examples

    In [15]: import IPython

    In [16]: _ip.cache_main_mod(IPython.__dict__,IPython.__file__)

    In [17]: len(_ip._main_ns_cache) > 0 Out[17]: True

    In [18]: _ip.clear_main_mod_cache()

    In [19]: len(_ip._main_ns_cache) == 0 Out[19]: True

  `color_info`

    A casting version of the boolean trait.

  `colors`

    An enum of strings that are caseless in validate.

  `colors_force`

    A casting version of the boolean trait.

  `complete`(text, line=None, cursor_pos=None)

    Return the completed text and a list of completions.

    Parameters :

    text : string

    > > A string of text to be completed on. It can be given as empty and instead a line/position pair are given. In this case, the completer itself will split the line like readline does.

    > line : string, optional

    >   The complete line that text is part of.

    > cursor_pos : int, optional

    >   The position of the cursor on the input line.

    Returns :

    text : string

    > > The actual text that was completed.

    > matches : list

    >   A sorted list with all possible completions.

    The optional arguments allow the completion to take more context into :

    account, and are part of the low-level completion API. :

    This is a wrapper around the completion mechanism, similar to what :

    readline does at the command line when the TAB key is hit. By :

    exposing it as a method, it can be used by other non-readline :

    environments (such as GUIs) for text completion. :

    Simple usage example: :

    In [1]: x = ‘hello’ :

    In [2]: _ip.complete(‘x.l’) :

    Out[2]: (‘x.l’, [‘x.ljust’, ‘x.lower’, ‘x.lstrip’]) :

  `config`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `debug`

    A casting version of the boolean trait.

  `debugger`(force=False)

    Call the pydb/pdb debugger.

    Keywords:

    > - force(False): by default, this routine checks the instance call_pdb

    > flag and does not actually invoke the debugger if the flag is false. The ‘force’ option forces the debugger to activate even if the flag is false.

  `deep_reload`

    A casting version of the boolean trait.

  `default_option`(fn, optstr)

    Make an entry in the options_table for fn, with value optstr

  `define_macro`(name, themacro)

    Define a new macro

    Parameters :

    name : str

    > The name of the macro.

    themacro : str or Macro

    > The action to do upon invoking the macro. If a string, a new Macro object is created by passing the string to it.

  `define_magic`(magicname, func)

    Expose own function as magic function for ipython

    Example:

        def foo_impl(self,parameter_s=''):
            'My very own magic!. (Use docstrings, IPython reads them).'
            print 'Magic function. Passed parameter is between < >:'
            print '<%s>' % parameter_s
            print 'The self object is:', self

        ip.define_magic('foo',foo_impl)

  `del_var`(varname, by_name=False)

    Delete a variable from the various namespaces, so that, as far as possible, we’re not keeping any hidden references to it.

    Parameters :

    varname : str

    > The name of the variable to delete.

    by_name : bool

    > If True, delete variables with the given name in each namespace. If False (default), find the variable in the user namespace, and delete references to it.

  `disable_failing_post_execute`

    A casting version of the boolean trait.

  `display_formatter`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `display_pub_class`

    A trait whose value must be a subclass of a specified class.

  `display_trap`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `displayhook_class`

    A trait whose value must be a subclass of a specified class.

  `drop_by_id`(variables)

    Remove a dict of variables from the user namespace, if they are the same as the values in the dictionary.

    This is intended for use by extensions: variables that they’ve added can be taken back out if they are unloaded, without removing any that the user has overwritten.

    Parameters :

    variables : dict

    > A dictionary mapping object names (as strings) to the objects.

  `enable_gui`(gui=None)
  `enable_pylab`(gui=None, import_all=True)

    Activate pylab support at runtime.

    This turns on support for matplotlib, preloads into the interactive namespace all of numpy and pylab, and configures IPython to correctly interact with the GUI event loop. The GUI backend to be used can be optionally selected with the optional :param:`gui` argument.

    Parameters :

    gui : optional, string

    > If given, dictates the choice of matplotlib GUI backend to use (should be one of IPython’s supported backends, ‘qt’, ‘osx’, ‘tk’, ‘gtk’, ‘wx’ or ‘inline’), otherwise we use the default chosen by matplotlib (as dictated by the matplotlib build-time options plus the user’s matplotlibrc configuration file). Note that not all backends make sense in all contexts, for example a terminal ipython can’t display figures inline.

  `ev`(expr)

    Evaluate python expression expr in user namespace.

    Returns the result of evaluation

  `ex`(cmd)

    Execute a normal python statement in user namespace.

  `excepthook`(etype, value, tb)

    One more defense for GUI apps that call sys.excepthook.

    GUI frameworks like wxPython trap exceptions and call sys.excepthook themselves. I guess this is a feature that enables them to keep running after exceptions that would otherwise kill their mainloop. This is a bother for IPython which excepts to catch all of the program exceptions with a try: except: statement.

    Normally, IPython sets sys.excepthook to a CrashHandler instance, so if any app directly invokes sys.excepthook, it will look to the user like IPython crashed. In order to work around this, we can disable the CrashHandler and replace it with this excepthook instead, which prints a regular traceback using our InteractiveTB. In this fashion, apps which call sys.excepthook will generate a regular-looking exception from IPython, and the CrashHandler will only be triggered by real IPython crashes.

    This hook should be used sparingly, only in places which are not likely to be true IPython errors.

  `execution_count`

    An integer trait.

    Longs that are unnecessary (<= sys.maxint) are cast to ints.

  `exit_now`

    A casting version of the boolean trait.

  `exiter`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `extension_manager`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `extract_input_lines`(range_str, raw=False)

    Return as a string a set of input history slices.

    Inputs:

    > - range_str: the set of slices is given as a string, like

    > “~5/6-~4/2 4:8 9”, since this function is for use by magic functions which get their arguments as strings. The number before the / is the session number: ~n goes n back from the current session.

    Optional inputs:

    > - raw(False): by default, the processed input is used. If this is

    > true, the raw input history is used instead.

    Note that slices can be called with two notations:

    N:M -> standard python form, means including items N...(M-1).

    N-M -> include items N..M (closed endpoint).

  `filename`

    A trait for unicode strings.

  `find_user_code`(target, raw=True)

    Get a code string from history, file, or a string or macro.

    This is mainly used by magic functions.

    Parameters :

    target : str

    > A string specifying code to retrieve. This will be tried respectively as: ranges of input history (see %history for syntax), a filename, or an expression evaluating to a string or Macro in the user namespace.

    raw : bool

    > If true (default), retrieve raw history. Has no effect on the other retrieval mechanisms.

    Returns : | A string of code. : ValueError is raised if nothing is found, and TypeError if it evaluates : to an object of another type. In each case, .args[0] is a printable : message. :

  `format_latex`(strng)

    Format a string for latex inclusion.

  `get_ipython`()

    Return the currently running IPython instance.

  `getoutput`(cmd, split=True)

    Get output (possibly including stderr) from a subprocess.

    Parameters :

    cmd : str

    > Command to execute (can not end in ‘&’, as background processes are not supported.

    split : bool, optional

    > If True, split the output into an IPython SList. Otherwise, an IPython LSString is returned. These are objects similar to normal lists and strings, with a few convenience attributes for easier manipulation of line-based output. You can use ‘?’ on them for details.

  `history_length`

    An integer trait.

    Longs that are unnecessary (<= sys.maxint) are cast to ints.

  `history_manager`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `init_alias`()
  `init_builtins`()
  `init_completer`()

    Initialize the completion machinery.

    This creates completion machinery that can be used by client code, either interactively in-process (typically triggered by the readline library), programatically (such as in test suites) or out-of-prcess (typically over the network by remote frontends).

  `init_create_namespaces`(user_module=None, user_ns=None)
  `init_display_formatter`()
  `init_display_pub`()
  `init_displayhook`()
  `init_encoding`()
  `init_environment`()

    Any changes we need to make to the user’s environment.

  `init_extension_manager`()
  `init_history`()

    Sets up the command history, and starts regular autosaves.

  `init_hooks`()
  `init_inspector`()
  `init_instance_attrs`()
  `init_io`()
  `init_ipython_dir`(ipython_dir)
  `init_logger`()
  `init_logstart`()

    Initialize logging in case it was requested at the command line.

  `init_magics`()
  `init_payload`()
  `init_pdb`()
  `init_plugin_manager`()
  `init_prefilter`()
  `init_profile_dir`(profile_dir)
  `init_prompts`()
  `init_pushd_popd_magic`()
  `init_readline`()

    Command history completion/saving/reloading.

  `init_reload_doctest`()
  `init_syntax_highlighting`()
  `init_sys_modules`()
  `init_traceback_handlers`(custom_exceptions)
  `init_user_ns`()

    Initialize all user-visible namespaces to their minimum defaults.

    Certain history lists are also initialized here, as they effectively act as user namespaces.

    Notes

    All data structures here are only filled in, they are NOT reset by this method. If they were not empty before, data will simply be added to therm.

  classmethod `initialized`()

    Has an instance been created?

  `input_splitter`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  classmethod `instance`(*args, **kwargs)

    Returns a global instance of this class.

    This method create a new instance if none have previously been created and returns a previously created instance is one already exists.

    The arguments and keyword arguments passed to this method are passed on to the `__init__()` method of the class upon instantiation.

    Examples

    Create a singleton class using instance, and retrieve it:

        >>> from IPython.config.configurable import SingletonConfigurable
        >>> class Foo(SingletonConfigurable): pass
        >>> foo = Foo.instance()
        >>> foo == Foo.instance()
        True

    Create a subclass that is retrived using the base class instance:

        >>> class Bar(SingletonConfigurable): pass
        >>> class Bam(Bar): pass
        >>> bam = Bam.instance()
        >>> bam == Bar.instance()
        True

  `ipython_dir`

    A trait for unicode strings.

  `logappend`

    A trait for unicode strings.

  `logfile`

    A trait for unicode strings.

  `logstart`

    A casting version of the boolean trait.

  `lsmagic`()

    Return a list of currently available magic functions.

    Gives a list of the bare names after mangling ([‘ls’,’cd’, ...], not [‘magic_ls’,’magic_cd’,...]

  `magic`(arg_s, next_input=None)

    Call a magic function by name.

    Input: a string containing the name of the magic function to call and any additional arguments to be passed to the magic.

    magic(‘name -opt foo bar’) is equivalent to typing at the ipython prompt:

    In[1]: %name -opt foo bar

    To call a magic without arguments, simply use magic(‘name’).

    This provides a proper Python function to call IPython’s magics in any valid Python code you can type at the interpreter, including loops and compound statements.

  `magic_alias`(parameter_s='')

    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 bracket echo “Input in brackets: <%l>” In [3]: bracket 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.

  `magic_autocall`(parameter_s='')

    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 [2]: float ——> float() Out[2]: 0.0

    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’

    # all-random (note for auto-testing)

  `magic_automagic`(parameter_s='')

    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.

  `magic_bookmark`(parameter_s='')

    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.

  `magic_cd`(parameter_s='')

    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 –foo: change to directory that matches ‘foo’ in 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’.

    Examples

        In [10]: cd parent/child
        /home/tsuser/parent/child

  `magic_colors`(parameter_s='')

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

    Currently implemented schemes: NoColor, Linux, LightBG.

    Color scheme names are not case-sensitive.

    Examples

    To get a plain black and white terminal:

        %colors nocolor

  `magic_config`(s)

    configure IPython

    > %config Class[.trait=value]

    This magic exposes most of the IPython config system. Any Configurable class should be able to be configured with the simple line:

        %config Class.trait=value

    Where value will be resolved in the user’s namespace, if it is an expression or variable name.

    Examples

    To see what classes are availabe for config, pass no arguments:

        In [1]: %config
        Available objects for config:
            TerminalInteractiveShell
            HistoryManager
            PrefilterManager
            AliasManager
            IPCompleter
            PromptManager
            DisplayFormatter

    To view what is configurable on a given class, just pass the class name:

        In [2]: %config IPCompleter
        IPCompleter options
        -----------------
        IPCompleter.omit__names=<Enum>
            Current: 2
            Choices: (0, 1, 2)
            Instruct the completer to omit private method names
            Specifically, when completing on ``object.<tab>``.
            When 2 [default]: all names that start with '_' will be excluded.
            When 1: all 'magic' names (``__foo__``) will be excluded.
            When 0: nothing will be excluded.
        IPCompleter.merge_completions=<CBool>
            Current: True
            Whether to merge completion results into a single list
            If False, only the completion results from the first non-empty completer
            will be returned.
        IPCompleter.greedy=<CBool>
            Current: False
            Activate greedy completion
            This will enable completion on elements of lists, results of function calls,
            etc., but can be unsafe because the code is actually evaluated on TAB.

    but the real use is in setting values:

        In [3]: %config IPCompleter.greedy = True

    and these values are read from the user_ns if they are variables:

        In [4]: feeling_greedy=False

        In [5]: %config IPCompleter.greedy = feeling_greedy

  `magic_debug`(parameter_s='')

    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.

  `magic_dhist`(parameter_s='')

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

  `magic_dirs`(parameter_s='')

    Return the current directory stack.

  `magic_doctest_mode`(parameter_s='')

    Toggle doctest mode on and off.

    This mode is intended to make IPython behave as much as possible like a plain Python shell, from the perspective of how its prompts, exceptions and output look. This makes it easy to copy and paste parts of a session into doctests. It does so by:

    - Changing the prompts to the classic `>>>` ones.
    - Changing the exception reporting mode to ‘Plain’.
    - Disabling pretty-printing of output.

    Note that IPython 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 -t’ to see the translated history; 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.

  `magic_ed`(parameter_s='')

    Alias to %edit.

  `magic_edit`(parameter_s='', last_call=['', ''])

    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 editor specified by your $EDITOR environment variable. 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 `TerminalInteractiveShell.editor` option in your configuration file. This is useful if you wish to use a different editor from your typical default with IPython (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:

    - If the argument is a filename, IPython will load that into the editor. It will execute its contents with execfile() when you exit, loading any code in the file into your interactive namespace.
    - The arguments are ranges of input history, e.g. “7 ~1/4-6”. The syntax is the same as in the %history magic.
    - If the argument is a string variable, its contents are 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.

    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 [5]: ed Editing... done. Executing edited code... hello Out[5]: “print ‘hello’n”

    Now we call it again with the previous output (stored in _):

    In [6]: ed _ Editing... done. Executing edited code... hello world Out[6]: “print ‘hello world’n”

    Now we call it with the output #8 (stored in _8, also as Out[8]):

    In [7]: ed _8 Editing... done. Executing edited code... hello again Out[7]: “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.core.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.

  `magic_env`(parameter_s='')

    List environment variables.

  `magic_gui`(parameter_s='')

    Enable or disable IPython GUI event loop integration.

    %gui [GUINAME]

    This magic replaces IPython’s threaded shells that were activated using the (pylab/wthread/etc.) command line flags. GUI toolkits can now be enabled at runtime and keyboard interrupts should work without any problems. The following toolkits are supported: wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX):

        %gui wx      # enable wxPython event loop integration
        %gui qt4|qt  # enable PyQt4 event loop integration
        %gui gtk     # enable PyGTK event loop integration
        %gui tk      # enable Tk event loop integration
        %gui OSX     # enable Cocoa event loop integration
                     # (requires %matplotlib 1.1)
        %gui         # disable all event loop integration

    WARNING: after any of these has been called you can simply create an application object, but DO NOT start the event loop yourself, as we have already handled that.

  `magic_install_default_config`(s)

    %install_default_config has been deprecated.

  `magic_install_profiles`(s)

    %install_profiles has been deprecated.

  `magic_load_ext`(module_str)

    Load an IPython extension by its module name.

  `magic_loadpy`(arg_s)

    Load a .py python script into the GUI console.

    This magic command can either take a local filename or a url:

        %loadpy myscript.py
        %loadpy http://www.example.com/myscript.py

  `magic_logoff`(parameter_s='')

    Temporarily stop logging.

    You must have previously started logging.

  `magic_logon`(parameter_s='')

    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.

  `magic_logstart`(parameter_s='')

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

  `magic_logstate`(parameter_s='')

    Print the status of the logging system.

  `magic_logstop`(parameter_s='')

    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.

  `magic_lsmagic`(parameter_s='')

    List currently available magic functions.

  `magic_macro`(parameter_s='')

    Define a macro for future re-execution. It accepts ranges of history, filenames or string objects.

    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 syntax for indicating input ranges is described in %history.

    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 [55]: %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’.

  `magic_magic`(parameter_s='')

    Print information about the magic function system.

    Supported formats: -latex, -brief, -rest

  `magic_notebook`(s)

    %notebook [-e] [-f FORMAT] filename

    Export and convert IPython notebooks. This function can export the current IPython history to a notebook file or can convert an existing notebook file into a different format. For example, to export the history to “foo.ipynb” do “%notebook -e foo.ipynb”. To export the history to “foo.py” do “%notebook -e foo.py”. To convert “foo.ipynb” to “foo.json” do “%notebook -f json foo.ipynb”. Possible formats include (json/ipynb, py).

    positional arguments:
      filename Notebook name or filename
    optional arguments:

      `-e, --export` | Export IPython history as a notebook. The filename argument is used to specify the notebook name and format. For example a filename of notebook.ipynb will result in a notebook name of “notebook” and a format of “xml”. Likewise using a ”.json” or ”.py” file extension will write the notebook in the json or py formats.
      `-f FORMAT, --format FORMAT`
      | Convert an existing IPython notebook to a new format. This option specifies the new format and can have the values: xml, json, py. The target filename is choosen automatically based on the new format. The filename argument gives the name of the source file.

  `magic_page`(parameter_s='')

    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.

  `magic_pastebin`(parameter_s='')

    Upload code to the ‘Lodge it’ paste bin, returning the URL.

  `magic_pdb`(parameter_s='')

    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 configuration file (the option is `InteractiveShell.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.

  `magic_pdef`(parameter_s='', namespaces=None)

    Print the definition header for any callable object.

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

    Examples

        In [3]: %pdef urllib.urlopen
        urllib.urlopen(url, data=None, proxies=None)

  `magic_pdoc`(parameter_s='', namespaces=None)

    Print the docstring for an object.

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

  `magic_pfile`(parameter_s='')

    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.

  `magic_pinfo`(parameter_s='', namespaces=None)

    Provide detailed information about an object.

    ‘%pinfo object’ is just a synonym for object? or ?object.

  `magic_pinfo2`(parameter_s='', namespaces=None)

    Provide extra detailed information about an object.

    ‘%pinfo2 object’ is just a synonym for object?? or ??object.

  `magic_popd`(parameter_s='')

    Change to directory popped off the top of the stack.

  `magic_pprint`(parameter_s='')

    Toggle pretty printing on/off.

  `magic_precision`(s='')

    Set floating point precision for pretty printing.

    Can set either integer precision or a format string.

    If numpy has been imported and precision is an int, numpy display precision will also be set, via `numpy.set_printoptions`.

    If no argument is given, defaults will be restored.

    Examples

        In [1]: from math import pi

        In [2]: %precision 3
        Out[2]: u'%.3f'

        In [3]: pi
        Out[3]: 3.142

        In [4]: %precision %i
        Out[4]: u'%i'

        In [5]: pi
        Out[5]: 3

        In [6]: %precision %e
        Out[6]: u'%e'

        In [7]: pi**10
        Out[7]: 9.364805e+04

        In [8]: %precision
        Out[8]: u'%r'

        In [9]: pi**10
        Out[9]: 93648.047476082982

  `magic_profile`(parameter_s='')

    Print your currently active IPython profile.

  `magic_prun`(parameter_s='', user_mode=1, opts=None, arg_lst=None, prog_ns=None)

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

  `magic_psearch`(parameter_s='')

    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 are given, the default is read from your configuration file, with the option `InteractiveShell.wildcards_case_sensitive`. If this option is not specified in your configuration 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

  `magic_psource`(parameter_s='', namespaces=None)

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

  `magic_pushd`(parameter_s='')

    Place the current dir on stack and change directory.

    Usage:
      %pushd [‘dirname’]
  `magic_pwd`(parameter_s='')

    Return the current working directory path.

    Examples

        In [9]: pwd
        Out[9]: '/home/tsuser/sprint/ipython'

  `magic_pycat`(parameter_s='')

    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.

  `magic_pylab`(s)

    Load numpy and matplotlib to work interactively.

    %pylab [GUINAME]

    This function lets you activate pylab (matplotlib, numpy and interactive support) at any point during an IPython session.

    It will import at the top level numpy as np, pyplot as plt, matplotlib, pylab and mlab, as well as all names from numpy and pylab.

    If you are using the inline matplotlib backend for embedded figures, you can adjust its behavior via the %config magic:

        # enable SVG figures, necessary for SVG+XHTML export in the qtconsole
        In [1]: %config InlineBackend.figure_format = 'svg'

        # change the behavior of closing all figures at the end of each
        # execution (cell), or allowing reuse of active figures across
        # cells:
        In [2]: %config InlineBackend.close_figures = False

    Parameters :

    guiname : optional

    > One of the valid arguments to the %gui magic (‘qt’, ‘wx’, ‘gtk’, ‘osx’ or ‘tk’). If given, the corresponding Matplotlib backend is used, otherwise matplotlib’s default (which you can override in your matplotlib config file) is used.

    Examples

    In this case, where the MPL default is TkAgg:

        In [2]: %pylab

        Welcome to pylab, a matplotlib-based Python environment.
        Backend in use: TkAgg
        For more information, type 'help(pylab)'.

    But you can explicitly request a different backend:

        In [3]: %pylab qt

        Welcome to pylab, a matplotlib-based Python environment.
        Backend in use: Qt4Agg
        For more information, type 'help(pylab)'.

  `magic_quickref`(arg)

    Show a quick reference sheet

  `magic_rehashx`(parameter_s='')

    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.

  `magic_reload_ext`(module_str)

    Reload an IPython extension by its module name.

  `magic_reset`(parameter_s='')

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

    Parameters :

    -f : force reset without asking for confirmation.

    > -s : ‘Soft’ reset: Only clears your namespace, leaving history intact. References to objects may be kept. By default (without this option), we do a ‘hard’ reset, giving you a new session and removing all references to objects from the current session.

    Examples

    In [6]: a = 1

    In [7]: a Out[7]: 1

    In [8]: ‘a’ in _ip.user_ns Out[8]: True

    In [9]: %reset -f

    In [1]: ‘a’ in _ip.user_ns Out[1]: False

  `magic_reset_selective`(parameter_s='')

    Resets the namespace by removing names defined by the user.

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

    %reset_selective [-f] regex

    No action is taken if regex is not included

    Options
      -f : force reset without asking for confirmation.

    Examples

    We first fully reset the namespace so your output looks identical to this example for pedagogical reasons; in practice you do not need a full reset.

    In [1]: %reset -f

    Now, with a clean namespace we can make a few variables and use %reset_selective to only delete names that match our regexp:

    In [2]: a=1; b=2; c=3; b1m=4; b2m=5; b3m=6; b4m=7; b2s=8

    In [3]: who_ls Out[3]: [‘a’, ‘b’, ‘b1m’, ‘b2m’, ‘b2s’, ‘b3m’, ‘b4m’, ‘c’]

    In [4]: %reset_selective -f b[2-3]m

    In [5]: who_ls Out[5]: [‘a’, ‘b’, ‘b1m’, ‘b2s’, ‘b4m’, ‘c’]

    In [6]: %reset_selective -f d

    In [7]: who_ls Out[7]: [‘a’, ‘b’, ‘b1m’, ‘b2s’, ‘b4m’, ‘c’]

    In [8]: %reset_selective -f c

    In [9]: who_ls Out[9]: [‘a’, ‘b’, ‘b1m’, ‘b2s’, ‘b4m’]

    In [10]: %reset_selective -f b

    In [11]: who_ls Out[11]: [‘a’]

  `magic_run`(parameter_s='', runner=None, file_finder=<function get_py_filename at 0x44ff848>)

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

    -m: specify module name to load instead of script path. Similar to the -m option for the python interpreter. Use this option last if you want to combine with other %run options. Unlike the python interpreter only source modules are allowed no .pyc or .pyo files. For example:

    > %run -m example

    will run the example module.

  `magic_save`(parameter_s='')

    Save a set of lines or a macro 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 %history for input ranges, then saves the lines 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.

  `magic_sc`(parameter_s='')

    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:

    # all-random

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

    > # a is a string with embedded newlines In [2]: a Out[2]: ‘setup.pynwin32_manual_post_install.py’

    > # which can be seen as a list: In [3]: a.l Out[3]: [‘setup.py’, ‘win32_manual_post_install.py’]

    > # or as a whitespace-separated string: In [4]: a.s Out[4]: ‘setup.py win32_manual_post_install.py’

    > # a.s is useful to pass as a single command line: In [5]: !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 [6]: 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 [7]: sc -l b=ls *py

    > In [8]: b Out[8]: [‘setup.py’, ‘win32_manual_post_install.py’]

    > In [9]: b.s Out[9]: ‘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.

  `magic_sx`(parameter_s='')

    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.

  `magic_tb`(s)

    Print the last traceback with the currently active exception mode.

    See %xmode for changing exception reporting modes.

  `magic_time`(parameter_s='')

    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

  `magic_timeit`(parameter_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.

  `magic_unalias`(parameter_s='')

    Remove an alias

  `magic_unload_ext`(module_str)

    Unload an IPython extension by its module name.

  `magic_who`(parameter_s='')

    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.

    Examples

    Define two variables and list them with who:

        In [1]: alpha = 123

        In [2]: beta = 'test'

        In [3]: %who
        alpha   beta

        In [4]: %who int
        alpha

        In [5]: %who str
        beta

  `magic_who_ls`(parameter_s='')

    Return a sorted list of all interactive variables.

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

    Examples

    Define two variables and list them with who_ls:

        In [1]: alpha = 123

        In [2]: beta = 'test'

        In [3]: %who_ls
        Out[3]: ['alpha', 'beta']

        In [4]: %who_ls int
        Out[4]: ['alpha']

        In [5]: %who_ls str
        Out[5]: ['beta']

  `magic_whos`(parameter_s='')

    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 arrays, a summary with shape, number of

    > elements, typecode and size in memory.

    > - Everything else: a string representation, snipping their middle if

    > too long.

    Examples

    Define two variables and list them with whos:

        In [1]: alpha = 123

        In [2]: beta = 'test'

        In [3]: %whos
        Variable   Type        Data/Info
        --------------------------------
        alpha      int         123
        beta       str         test

  `magic_xdel`(parameter_s='')

    Delete a variable, trying to clear it from anywhere that IPython’s machinery has references to it. By default, this uses the identity of the named object in the user namespace to remove references held under other names. The object is also removed from the output history.

    Options
      -n : Delete the specified name from all namespaces, without checking their identity.
  `magic_xmode`(parameter_s='')

    Switch modes for the exception handlers.

    Valid modes: Plain, Context and Verbose.

    If called without arguments, acts as a toggle.

  `mktempfile`(data=None, prefix='ipython_edit_')

    Make a new tempfile and return its filename.

    This makes a call to tempfile.mktemp, but it registers the created filename internally so ipython cleans it up at exit time.

    Optional inputs:

    > - data(None): if data is given, it gets written out to the temp file

    > immediately, and the file is closed again.

  `multiline_history`

    A casting version of the boolean trait.

  `new_main_mod`(ns=None)

    Return a new ‘main’ module object for user code execution.

  `object_info_string_level`

    An enum that whose value must be in a given sequence.

  `object_inspect`(oname)
  `on_trait_change`(handler, name=None, remove=False)

    Setup a handler to be called when a trait changes.

    This is used to setup dynamic notifications of trait changes.

    Static handlers can be created by creating methods on a HasTraits subclass with the naming convention ‘_[traitname]_changed’. Thus, to create static handler for the trait ‘a’, create the method _a_changed(self, name, old, new) (fewer arguments can be used, see below).

    Parameters :

    handler : callable

    > A callable that is called when a trait changes. Its signature can be handler(), handler(name), handler(name, new) or handler(name, old, new).

    name : list, str, None

    > If None, the handler will apply to all traits. If a list of str, handler will apply to all names in the list. If a str, the handler will apply just to that name.

    remove : bool

    > If False (the default), then install the handler. If True then unintall it.

  `parse_options`(arg_str, opt_str, *long_opts, **kw)

    Parse options passed to an argument string.

    The interface is similar to that of getopt(), but it returns back a Struct with the options as keys and the stripped argument string still as a string.

    arg_str is quoted as a true sys.argv vector by using shlex.split. This allows us to easily expand variables, glob files, quote arguments, etc.

    Options:

      -mode: default ‘string’. If given as ‘list’, the argument string is returned as a list (split on whitespace) instead of a string.

      -list_all: put all option values in lists. Normally only options appearing more than once are put in a list.

      -posix (True): whether to split the input line in POSIX mode or not, as per the conventions outlined in the shlex module from the standard library.

  `payload_manager`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `pdb`

    A casting version of the boolean trait.

  `plugin_manager`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `pre_readline`()

    readline hook to be used at the start of each line.

    Currently it handles auto-indent only.

  `prefilter_manager`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `prepare_user_module`(user_module=None, user_ns=None)

    Prepare the module and namespace in which user code will be run.

    When IPython is started normally, both parameters are None: a new module is created automatically, and its __dict__ used as the namespace.

    If only user_module is provided, its __dict__ is used as the namespace. If only user_ns is provided, a dummy module is created, and user_ns becomes the global namespace. If both are provided (as they may be when embedding), user_ns is the local namespace, and user_module provides the global namespace.

    Parameters :

    user_module : module, optional

    > The current user module in which IPython is being run. If None, a clean module will be created.

    user_ns : dict, optional

    > A namespace in which to run interactive commands.

    Returns : | A tuple of user_module and user_ns, each properly initialised. :

  `profile`
  `profile_dir`

    A trait whose value must be an instance of a specified class.

    The value can also be an instance of a subclass of the specified class.

  `profile_missing_notice`(*args, **kwargs)
  `prompt_in1`

    A trait for unicode strings.

  `prompt_in2`

    A trait for unicode strings.

  `prompt_out`

    A trait for unicode strings.

  `prompts_pad_left`

    A casting version of the boolean trait.

  `push`(variables, interactive=True)

    Inject a group of variables into the IPython user namespace.

    Parameters :

    variables : dict, str or list/tuple of str

    > The variables to inject into the user’s namespace. If a dict, a simple update is done. If a str, the string is assumed to have variable names separated by spaces. A list/tuple of str can also be used to give the variable names. If just the variable names are give (list/tuple/str) then the variable values looked up in the callers frame.

    interactive : bool

    > If True (default), the variables will be listed with the `who` magic.

  `quiet`

    A casting version of the boolean trait.

  `readline_parse_and_bind`

    An instance of a Python list.

  `readline_remove_delims`

    A trait for unicode strings.

  `readline_use`

    A casting version of the boolean trait.

  `refill_readline_hist`()
  `register_post_execute`(func)

    Register a function for calling after code execution.

  `reset`(new_session=True)

    Clear all internal namespaces, and attempt to release references to user objects.

    If new_session is True, a new history session will be opened.

  `reset_selective`(regex=None)

    Clear selective variables from internal namespaces based on a specified regular expression.

    Parameters :

    regex : string or compiled pattern, optional

    > A regular expression pattern that will be used in searching variable names in the users namespaces.

  `restore_sys_module_state`()

    Restore the state of the sys module.

  `run_ast_nodes`(nodelist, cell_name, interactivity='last_expr')

    Run a sequence of AST nodes. The execution mode depends on the interactivity parameter.

    Parameters :

    nodelist : list

    > A sequence of AST nodes to run.

    cell_name : str

    > Will be passed to the compiler as the filename of the cell. Typically the value returned by ip.compile.cache(cell).

    interactivity : str

    > ‘all’, ‘last’, ‘last_expr’ or ‘none’, specifying which nodes should be run interactively (displaying output from expressions). ‘last_expr’ will run the last node interactively only if it is an expression (i.e. expressions in loops or other blocks are not displayed. Other values for this parameter will raise a ValueError.

  `run_cell`(raw_cell, store_history=False)

    Run a complete IPython cell.

    Parameters :

    raw_cell : str

    > The code (including IPython code such as %magic functions) to run.

    store_history : bool

    > If True, the raw and translated cell will be stored in IPython’s history. For user code calling back into IPython’s machinery, this should be set to False.

  `run_code`(code_obj)

    Execute a code object.

    When an exception occurs, self.showtraceback() is called to display a traceback.

    Parameters :

    code_obj : code object

    > A compiled code object, to be executed

    post_execute : bool [default: True]

    > whether to call post_execute hooks after this particular execution.

    Returns : | False : successful execution. True : an error occurred.

  `runcode`(code_obj)

    Execute a code object.

    When an exception occurs, self.showtraceback() is called to display a traceback.

    Parameters :

    code_obj : code object

    > A compiled code object, to be executed

    post_execute : bool [default: True]

    > whether to call post_execute hooks after this particular execution.

    Returns : | False : successful execution. True : an error occurred.

  `safe_execfile`(fname, *where, **kw)

    A safe version of the builtin execfile().

    This version will never throw an exception, but instead print helpful error messages to the screen. This only works on pure Python files with the .py extension.

    Parameters :

    fname : string

    > The name of the file to be executed.

    where : tuple

    > One or two namespaces, passed to execfile() as (globals,locals). If only one is given, it is passed as both.

    exit_ignore : bool (False)

    > If True, then silence SystemExit for non-zero status (it is always silenced for zero status, as it is so common).

    raise_exceptions : bool (False)

    > If True raise exceptions everywhere. Meant for testing.

  `safe_execfile_ipy`(fname)

    Like safe_execfile, but for .ipy files with IPython syntax.

    Parameters :

    fname : str

    > The name of the file to execute. The filename must have a .ipy extension.

  `save_sys_module_state`()

    Save the state of hooks in the sys module.

    This has to be called after self.user_module is created.

  `separate_in`

    A Unicode subclass to validate separate_in, separate_out, etc.

    > This is a Unicode based trait that converts ‘0’->’’ and ‘n’->’

    ‘.

  `separate_out`

    A Unicode subclass to validate separate_in, separate_out, etc.

    > This is a Unicode based trait that converts ‘0’->’’ and ‘n’->’

    ‘.

  `separate_out2`

    A Unicode subclass to validate separate_in, separate_out, etc.

    > This is a Unicode based trait that converts ‘0’->’’ and ‘n’->’

    ‘.

  `set_autoindent`(value=None)

    Set the autoindent flag, checking for readline support.

    If called with no arguments, it acts as a toggle.

  `set_completer_frame`(frame=None)

    Set the frame of the completer.

  `set_custom_completer`(completer, pos=0)

    Adds a new custom completer function.

    The position argument (defaults to 0) is the index in the completers list where you want the completer to be inserted.

  `set_custom_exc`(exc_tuple, handler)

    Set a custom exception handler, which will be called if any of the exceptions in exc_tuple occur in the mainloop (specifically, in the run_code() method).

    Parameters :

    exc_tuple : tuple of exception classes

    > A tuple of exception classes, for which to call the defined handler. It is very important that you use a tuple, and NOT A LIST here, because of the way Python’s except statement works. If you only want to trap a single exception, use a singleton tuple:

    >     exc_tuple == (MyCustomException,)

    handler : callable

    > handler must have the following signature:

    >     def my_handler(self, etype, value, tb, tb_offset=None):
    >         ...
    >         return structured_traceback

    > Your handler must return a structured traceback (a list of strings), or None.

    > This will be made into an instance method (via types.MethodType) of IPython itself, and it will be called if any of the exceptions listed in the exc_tuple are caught. If the handler is None, an internal basic one is used, which just prints basic info.

    > To protect IPython from crashes, if your handler ever raises an exception or returns an invalid result, it will be immediately disabled.

    WARNING: by putting in your own exception handler into IPython’s main :

    execution loop, you run a very good chance of nasty crashes. This :

    facility should only be used if you really know what you are doing. :

  `set_hook`(name, hook, priority=50, str_key=None, re_key=None)

    set_hook(name,hook) -> sets an internal IPython hook.

    IPython exposes some of its internal API as user-modifiable hooks. By adding your function to one of these hooks, you can modify IPython’s behavior to call at runtime your own routines.

  `set_next_input`(s)

    Sets the ‘default’ input string for the next command line.

    Requires readline.

    Example:

    [D:ipython]|1> _ip.set_next_input(“Hello Word”) [D:ipython]|2> Hello Word_ # cursor is here

  `set_readline_completer`()

    Reset readline’s completer to be our own.

  `show_rewritten_input`

    A casting version of the boolean trait.

  `show_usage`()

    Show a usage message

  `showindentationerror`()

    Called by run_cell when there’s an IndentationError in code entered at the prompt.

    This is overridden in TerminalInteractiveShell to show a message about the %paste magic.

  `showsyntaxerror`(filename=None)

    Display the syntax error that just occurred.

    This doesn’t display a stack trace because there isn’t one.

    If a filename is given, it is stuffed in the exception instead of what was there before (because Python’s parser always uses “<string>” when reading from a string).

  `showtraceback`(exc_tuple=None, filename=None, tb_offset=None, exception_only=False)

    Display the exception that just occurred.

    If nothing is known about the exception, this is the method which should be used throughout the code for presenting user tracebacks, rather than directly invoking the InteractiveTB object.

    A specific showsyntaxerror() also exists, but this method can take care of calling it if needed, so unless you are explicitly catching a SyntaxError exception, don’t try to analyze the stack manually and simply call this method.

  `system`(cmd)

    Call the given cmd in a subprocess, piping stdout/err

    Parameters :

    cmd : str

    > Command to execute (can not end in ‘&’, as background processes are not supported. Should not be a command that expects input other than simple text.

  `system_piped`(cmd)

    Call the given cmd in a subprocess, piping stdout/err

    Parameters :

    cmd : str

    > Command to execute (can not end in ‘&’, as background processes are not supported. Should not be a command that expects input other than simple text.

  `system_raw`(cmd)

    Call the given cmd in a subprocess using os.system

    Parameters :

    cmd : str

    > Command to execute.

  `trait_metadata`(traitname, key)

    Get metadata values for trait by key.

  `trait_names`(**metadata)

    Get a list of all the names of this classes traits.

  `traits`(**metadata)

    Get a list of all the traits of this class.

    The TraitTypes returned don’t know anything about the values that the various HasTrait’s instances are holding.

    This follows the same algorithm as traits does and does not allow for any simple way of specifying merely that a metadata name exists, but has any value. This is because get_metadata returns None if a metadata key doesn’t exist.

  `update_config`(config)

    Fire the traits events when the config is updated.

  `user_expressions`(expressions)

    Evaluate a dict of expressions in the user’s namespace.

    Parameters :

    expressions : dict

    > A dict with string keys and string values. The expression values should be valid Python expressions, each of which will be evaluated in the user namespace.

    Returns : | A dict, keyed like the input expressions dict, with the repr() of each : value. :

  `user_global_ns`
  `user_variables`(names)

    Get a list of variable names from the user’s namespace.

    Parameters :

    names : list of strings

    > A list of names of variables to be read from the user namespace.

    Returns : | A dict, keyed by the input names and with the repr() of each value. :

  `var_expand`(cmd, depth=0, formatter=<IPython.utils.text.DollarFormatter object at 0x47a3350>)

    Expand python variables in a string.

    The depth argument indicates how many frames above the caller should be walked to look for the local namespace where to expand variables.

    The global namespace for expansion is always the user’s interactive namespace.

  `wildcards_case_sensitive`

    A casting version of the boolean trait.

  `write`(data)

    Write a string to the default output

  `write_err`(data)

    Write a string to the default error output

  `xmode`

    An enum of strings that are caseless in validate.

### `InteractiveShellABC`

class `IPython.core.interactiveshell.``InteractiveShellABC`

  Bases: `object`

  An abstract base class for InteractiveShell.

  `__init__`()

    x.__init__(...) initializes x; see help(type(x)) for signature

### `NoOpContext`

class `IPython.core.interactiveshell.``NoOpContext`

  Bases: `object`

  `__init__`()

    x.__init__(...) initializes x; see help(type(x)) for signature

### `ReadlineNoRecord`

class `IPython.core.interactiveshell.``ReadlineNoRecord`(shell)

  Bases: `object`

  Context manager to execute some code, then reload readline history so that interactive input to the code doesn’t appear when pressing up.

  `__init__`(shell)
  `current_length`()
  `get_readline_tail`(n=10)

    Get the last n items in readline history.

### `SeparateUnicode`

class `IPython.core.interactiveshell.``SeparateUnicode`(default_value=<IPython.utils.traitlets.NoDefaultSpecified object at 0x451fd10>, **metadata)

  Bases: `IPython.utils.traitlets.Unicode`

  A Unicode subclass to validate separate_in, separate_out, etc.

  > This is a Unicode based trait that converts ‘0’->’’ and ‘n’->’

  ‘.

  `__init__`(default_value=<IPython.utils.traitlets.NoDefaultSpecified object at 0x451fd10>, **metadata)

    Create a TraitType.

  `error`(obj, value)
  `get_default_value`()

    Create a new instance of the default value.

  `get_metadata`(key)
  `info`()
  `init`()
  `instance_init`(obj)

    This is called by `HasTraits.__new__()` to finish init’ing.

    Some stages of initialization must be delayed until the parent `HasTraits` instance has been created. This method is called in `HasTraits.__new__()` after the instance has been created.

    This method trigger the creation and validation of default values and also things like the resolution of str given class names in `Type` and :class`Instance`.

    Parameters :

    obj : `HasTraits` instance

    > The parent `HasTraits` instance that has just been created.

  `set_default_value`(obj)

    Set the default value on a per instance basis.

    This method is called by `instance_init()` to create and validate the default value. The creation and validation of default values must be delayed until the parent `HasTraits` class has been instantiated.

  `set_metadata`(key, value)
  `validate`(obj, value)

### `SpaceInInput`

class `IPython.core.interactiveshell.``SpaceInInput`

  Bases: `exceptions.Exception`

  `__init__`()

    x.__init__(...) initializes x; see help(type(x)) for signature

  `args`
  `message`

## Functions

`IPython.core.interactiveshell.``get_default_colors`()

`IPython.core.interactiveshell.``no_op`(*a, **kw)

`IPython.core.interactiveshell.``softspace`(file, newvalue)

  Copied from code.py, to remove the dependency

### Navigation

- index
- modules |
- next |
- previous |
- home|
- search|
- documentation »
- The IPython API »