IPython's 'magic' functions
===========================
注意：既然是IPython的内置magic函数，那么在Pycharm中是不会支持的。The magic function system provides a series of functions which allow you to
control the behavior of IPython itself, plus a lot of system-type
features. There are two kinds of magics, line-oriented and cell-oriented.Line magics are prefixed with the % character and work much like OS
command-line calls: they get as an argument the rest of the line, where
arguments are passed without parentheses or quotes.  For example, this will
time the given statement::%timeit range(1000)Cell magics are prefixed with a double %%, and they are functions that get as
an argument not only the rest of the line, but also the lines below it in a
separate argument.  These magics are called with two arguments: the rest of the
call line and the body of the cell, consisting of the lines below the first.
For example::%%timeit x = numpy.random.randn((100, 100))numpy.linalg.svd(x)will time the execution of the numpy svd routine, running the assignment of x
as part of the setup phase, which is not timed.In a line-oriented client (the terminal or Qt console IPython), starting a new
input with %% will automatically enter cell mode, and IPython will continue
reading input until a blank line is given.  In the notebook, simply type the
whole cell as one entity, but keep in mind that the %% escape can only be at
the very start of the cell.NOTE: If you have 'automagic' enabled (via the command line option or with the
%automagic function), you don't need to type in the % explicitly for line
magics; cell magics always require an explicit '%%' escape.  By default,
IPython ships with automagic on, so you should only rarely need the % escape.Example: typing '%cd mydir' (without the quotes) changes your working directory
to 'mydir', if it exists.For a list of the available magic functions, use %lsmagic. For a description
of any of them, type %magic_name?, e.g. '%cd?'.Currently the magic system has the following functions:
%alias:Define an alias for a system command.'%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'Then, typing 'alias_name params' will execute the system command 'cmdparams' (from your underlying operating system).Aliases have lower precedence than magic functions and Python normalvariables, so if 'foo' is both a Python variable and an alias, thealias can not be executed until 'del foo' removes the Python variable.You can use the %l specifier in an alias definition to represent thewhole line when the alias is called.  For example::In [2]: alias bracket echo "Input in brackets: <%l>"In [3]: bracket hello worldInput in brackets: <hello world>You can also define aliases with parameters using %s specifiers (oneper parameter)::In [1]: alias parts echo first %s second %sIn [2]: %parts A Bfirst A second BIn [3]: %parts AIncorrect 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 orthe other in your aliases.Aliases expand Python variables just like system calls using ! or !!do: all expressions prefixed with '$' get expanded.  For details ofthe semantic rules, see PEP-215:http://www.python.org/peps/pep-0215.html.  This is the library used byIPython for variable expansion.  If you want to access a true shellvariable, an extra $ is necessary to prevent its expansion byIPython::In [6]: alias show echoIn [7]: PATH='A Python string'In [8]: show $PATHA Python stringIn [9]: show $$PATH/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...You can use the alias facility to access all of $PATH.  See the %rehashxfunction, which automatically creates aliases for the contents of your$PATH.If called with no parameters, %alias prints the current alias tablefor your system.  For posix systems, the default aliases are 'cat','cp', 'mv', 'rm', 'rmdir', and 'mkdir', and other platform-specificaliases are added.  For windows-based systems, the default aliases are'copy', 'ddir', 'echo', 'ls', 'ldir', 'mkdir', 'ren', and 'rmdir'.You can see the definition of alias by adding a question mark in theend::In [1]: cat?Repr: <alias cat for 'cat'>
%alias_magic:::%alias_magic [-l] [-c] [-p PARAMS] name targetCreate an alias for an existing line or cell magic.Examples--------::In [1]: %alias_magic t timeitCreated `%t` as an alias for `%timeit`.Created `%%t` as an alias for `%%timeit`.In [2]: %t -n1 pass1 loops, best of 3: 954 ns per loopIn [3]: %%t -n1...: pass...:1 loops, best of 3: 954 ns per loopIn [4]: %alias_magic --cell whereami pwdUsageError: Cell magic function `%%pwd` not found.In [5]: %alias_magic --line whereami pwdCreated `%whereami` as an alias for `%pwd`.In [6]: %whereamiOut[6]: u'/home/testuser'In [7]: %alias_magic h history "-p -l 30" --lineCreated `%h` as an alias for `%history -l 30`.positional arguments:name                  Name of the magic to be created.target                Name of the existing line or cell magic.optional arguments:-l, --line            Create a line magic alias.-c, --cell            Create a cell magic alias.-p PARAMS, --params PARAMSParameters passed to the magic function.
%autoawait:Allow to change the status of the autoawait option.This allow you to set a specific asynchronous code runner.If no value is passed, print the currently used asynchronous integrationand whether it is activated.It can take a number of value evaluated in the following order:- False/false/off deactivate autoawait integration- True/true/on activate autoawait integration using configured defaultloop- asyncio/curio/trio activate autoawait integration and use integrationwith said library.- `sync` turn on the pseudo-sync integration (mostly used for`IPython.embed()` which does not run IPython with a real eventloop anddeactivate running asynchronous code. Turning on Asynchronous code withthe pseudo sync loop is undefined behavior and may lead IPython to crash.If the passed parameter does not match any of the above and is a pythonidentifier, get said object from user namespace and set it as therunner, and activate autoawait. If the object is a fully qualified object name, attempt to import it andset it as the runner, and activate autoawait.The exact behavior of autoawait is experimental and subject to changeacross version of IPython and Python.
%autocall:Make functions callable without having to type parentheses.Usage:%autocall [mode]The mode can be one of: 0->Off, 1->Smart, 2->Full.  If not given, thevalue is toggled on and off (remembering the previous state).In more detail, these values mean:0 -> fully disabled1 -> active, but do not apply if there are no arguments on the line.In this mode, you get::In [1]: callableOut[1]: <built-in function callable>In [2]: callable 'hello'------> callable('hello')Out[2]: False2 -> Active always.  Even if no arguments are present, the callableobject is called::In [2]: float------> float()Out[2]: 0.0Note that even with autocall off, you can still use '/' at the start ofa line to treat the first argument on the command line as a functionand add parentheses to it::In [8]: /str 43------> str(43)Out[8]: '43'# all-random (note for auto-testing)
%automagic:Make magic functions callable without having to type the initial %.Without arguments toggles on/off (when off, you must call it as%automagic, of course).  With arguments it sets the value, and you canuse 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 avariable whose name collides with that of a magic fn, automagic won'twork for that function (you get the variable instead). However, if youdelete the variable (del var), the previously shadowed magic functionbecomes visible to automagic again.
%autosave:Set the autosave interval in the notebook (in seconds).The default value is 120, or two minutes.``%autosave 0`` will disable autosave.This magic only has an effect when called from the notebook interface.It has no effect when called in a startup file.
%bookmark:Manage IPython's bookmark system.%bookmark <name>       - set bookmark to current dir%bookmark <name> <dir> - set bookmark to <dir>%bookmark -l           - list all bookmarks%bookmark -d <name>    - remove bookmark%bookmark -r           - remove all bookmarksYou can later on access a bookmarked folder with::%cd -b <name>or simply '%cd <name>' if there is no directory called <name> ANDthere is such a bookmark defined.Your bookmarks persist through IPython sessions, but they areassociated with each profile.
%cd:Change the current working directory.This command automatically maintains an internal list of directoriesyou visit during your IPython session, in the variable _dh. Thecommand %dhist shows this history nicely formatted. You can alsodo '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 historycd -b <bookmark_name>: jump to a bookmark set by %bookmark(note: cd <bookmark_name> is enough if there is nodirectory <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 isexecuted.  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
%clear:Clear the terminal.
%cls:Clear the terminal.
%colors: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
%conda:Run the conda package manager within the current kernel.Usage:%conda install [pkgs]
%config:configure IPython%config Class[.trait=value]This magic exposes most of the IPython config system. AnyConfigurable class should be able to be configured with the simpleline::%config Class.trait=valueWhere `value` will be resolved in the user's namespace, if it is anexpression or variable name.Examples--------To see what classes are available for config, pass no arguments::In [1]: %configAvailable objects for config:TerminalInteractiveShellHistoryManagerPrefilterManagerAliasManagerIPCompleterDisplayFormatterTo view what is configurable on a given class, just pass the classname::In [2]: %config IPCompleterIPCompleter options-----------------IPCompleter.omit__names=<Enum>Current: 2Choices: (0, 1, 2)Instruct the completer to omit private method namesSpecifically, 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: TrueWhether to merge completion results into a single listIf False, only the completion results from the first non-emptycompleter will be returned.IPCompleter.limit_to__all__=<CBool>Current: FalseInstruct the completer to use __all__ for the completionSpecifically, when completing on ``object.<tab>``.When True: only those names in obj.__all__ will be included.When False [default]: the __all__ attribute is ignoredIPCompleter.greedy=<CBool>Current: FalseActivate greedy completionThis will enable completion on elements of lists, results offunction calls, etc., but can be unsafe because the code isactually evaluated on TAB.but the real use is in setting values::In [3]: %config IPCompleter.greedy = Trueand these values are read from the user_ns if they are variables::In [4]: feeling_greedy=FalseIn [5]: %config IPCompleter.greedy = feeling_greedy
%connect_info:Print information for connecting other clients to this kernelIt will print the contents of this session's connection file, as well asshortcuts for local clients.In the simplest case, when called from the most recently launched kernel,secondary clients can be connected, simply with:$> jupyter <app> --existing
%copy:Alias for `!copy`
%ddir:Alias for `!dir /ad /on`
%debug:::%debug [--breakpoint FILE:LINE] [statement [statement ...]]Activate the interactive debugger.This magic command support two ways of activating debugger.One is to activate debugger before executing code.  This way, youcan set a break point, to step through the code from the point.You can use this mode by giving statements to execute and optionallya breakpoint.The other one is to activate debugger in post-mortem mode.  You canactivate this mode simply running %debug without any argument.If an exception has just occurred, this lets you inspect its stackframes interactively.  Note that this will always work only on the lasttraceback that occurred, so you must call this quickly after anexception that you wish to inspect has fired, because if another oneoccurs, it clobbers the previous one.If you want IPython to automatically do this on every exception, seethe %pdb magic for more details... versionchanged:: 7.3When running code, user variables are no longer expanded,the magic line is always left unmodified.positional arguments:statement             Code to run in debugger. You can omit this in cell magic mode.optional arguments:--breakpoint <FILE:LINE>, -b <FILE:LINE>Set break point at LINE in FILE.
%dhist:Print your history of visited directories.%dhist       -> print full history%dhist n     -> print last n entries only%dhist n1 n2 -> print entries between n1 and n2 (n2 not included)This history is automatically maintained by the %cd command, andalways 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 enteringcd -<TAB>.
%dirs:Return the current directory stack.
%doctest_mode:Toggle doctest mode on and off.This mode is intended to make IPython behave as much as possible like aplain Python shell, from the perspective of how its prompts, exceptionsand output look.  This makes it easy to copy and paste parts of asession 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 haveleading '>>>' and '...' prompts in them.  This means that you can pastedoctests from files or docstrings (even if they have leadingwhitespace), and the code will execute correctly.  You can then use'%history -t' to see the translated history; this will give you theinput after removal of all the leading prompts and whitespace, whichcan be pasted back into an editor.With these features, you can switch into this mode easily whenever youneed to do testing and changes to doctests, without having to leaveyour existing IPython session.
%echo:Alias for `!echo`
%ed:Alias for `%edit`.
%edit:Bring up an editor and execute the resulting code.Usage:%edit [options] [args]%edit runs an external text editor. You will need to set the command forthis editor via the ``TerminalInteractiveShell.editor`` option in yourconfiguration file before it will work.This command allows you to conveniently edit multi-line code right inyour IPython session.If called without arguments, %edit opens up an empty editor with atemporary file and will execute the contents of this file when youclose it (don't forget to save it!).Options:-n <number>Open the editor at a specified line number. By default, the IPythoneditor hook uses the unix syntax 'editor +N filename', but you canconfigure this by providing your own modified hook if your favoriteeditor supports line-number specifications with a different syntax.-pCall the editor with the same data as the previous time it was used,regardless of how long ago (in your current session) it was.-rUse 'raw' input. This option only applies to input taken from theuser's history.  By default, the 'processed' history is used, so thatmagics are loaded in their transformed version to valid Python.  Ifthis option is given, the raw input as typed as the command line isused instead.  When you exit the editor, it will be executed byIPython's own processor.Arguments:If arguments are given, the following possibilities exist:- The arguments are numbers or pairs of colon-separated numbers (like1 4:8 9). These are interpreted as lines of previous input to beloaded 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 avariable and its contents loaded into the editor. You can thus editany string which contains python code (including the result ofprevious 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 theeditor 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 yourspecified 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 someeditors (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 afile with that name (adding .py if necessary) and load it into theeditor. It will execute its contents with execfile() when you exit,loading any code in the file into your interactive namespace.Unlike in the terminal, this is designed to use a GUI editor, and we donot know when it has closed. So the file you edit will not beautomatically executed or printed.Note that %edit is also available through the alias %ed.
%env:Get, set, or list environment variables.Usage:%env: lists all environment variables/values%env var: get value for var%env var val: set value for var%env var=val: set value for var%env var=$val: set value for var, using python expansion if possible
%gui:Enable or disable IPython GUI event loop integration.%gui [GUINAME]This magic replaces IPython's threaded shells that were activatedusing the (pylab/wthread/etc.) command line flags.  GUI toolkitscan now be enabled at runtime and keyboardinterrupts should work without any problems.  The following toolkitsare supported:  wxPython, PyQt4, PyGTK, Tk and Cocoa (OSX)::%gui wx      # enable wxPython event loop integration%gui qt4|qt  # enable PyQt4 event loop integration%gui qt5     # enable PyQt5 event loop integration%gui gtk     # enable PyGTK event loop integration%gui gtk3    # enable Gtk3 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 integrationWARNING:  after any of these has been called you can simply createan application object, but DO NOT start the event loop yourself, aswe have already handled that.
%hist:Alias for `%history`.
%history:::%history [-n] [-o] [-p] [-t] [-f FILENAME] [-g [PATTERN [PATTERN ...]]] [-l [LIMIT]] [-u] [range [range ...]]Print input history (_i<n> variables), with most recent last.By default, input history is printed without line numbers so it can bedirectly pasted into an editor. Use -n to show them.By default, all input history from the current session is displayed.Ranges of history can be indicated using the syntax:``4``Line 4, current session``4-6``Lines 4-6, current session``243/1-5``Lines 1-5, session 243``~2/7``Line 7, session 2 before current``~8/1-~6/5``From the first line of 8 sessions ago, to the fifth line of 6sessions ago.Multiple ranges can be entered, separated by spacesThe same syntax is used by %macro, %save, %edit, %rerunExamples--------::In [6]: %history -n 4-64:a = 125:print a**26:%history -n 4-6positional arguments:rangeoptional arguments:-n                    print line numbers for each input. This feature is only available if numbered prompts are inuse.-o                    also print outputs for each input.-p                    print classic '>>>' python prompts before each input. This is useful for making documentation,and in conjunction with -o, for producing doctest-ready output.-t                    print the 'translated' history, as IPython understands it. IPython filters your input andconverts it all into valid Python source before executing it (things like magics or aliasesare turned into function calls, for example). With this option, you'll see the native historyinstead of the user-entered version: '%cd /' will be seen as'get_ipython().run_line_magic("cd", "/")' instead of '%cd /'.-f FILENAME           FILENAME: instead of printing the output to the screen, redirect it to the given file. Thefile is always overwritten, though *when it can*, IPython asks for confirmation first. Inparticular, running the command 'history -f FILENAME' from the IPython Notebook interface willreplace FILENAME even if it already exists *without* confirmation.-g <[PATTERN [PATTERN ...]]>treat the arg as a glob pattern to search for in (full) history. This includes the savedhistory (almost all commands ever written). The pattern may contain '?' to match one unknowncharacter and '*' to match any number of unknown characters. Use '%hist -g' to show full savedhistory (may be very long).-l <[LIMIT]>          get the last n lines from all sessions. Specify n as a single arg, or the default is the last10 lines.-u                    when searching history using `-g`, show only unique history.
%killbgscripts:Kill all BG processes started by %%script and its family.
%ldir:Alias for `!dir /ad /on`
%less:Show a file through the pager.Files ending in .py are syntax-highlighted.
%load:Load code into the current frontend.Usage:%load [options] sourcewhere source can be a filename, URL, input history range, macro, orelement in the user namespaceOptions:-r <lines>: Specify lines or ranges of lines to load from the source.Ranges could be specified as x-y (x..y) or in python-style x:y (x..(y-1)). Both limits x and y can be left blank (meaning the beginning and end of the file, respectively).-s <symbols>: Specify function or classes to load from python source. -y : Don't ask confirmation for loading source above 200 000 characters.-n : Include the user's namespace when searching for source code.This magic command can either take a local filename, a URL, an historyrange (see %history) or a macro as argument, it will prompt forconfirmation before loading source with more than 200 000 characters, unless-y flag is passed or if the frontend does not support raw_input::%load myscript.py%load 7-27%load myMacro%load http://www.example.com/myscript.py%load -r 5-10 myscript.py%load -r 10-20,30,40: foo.py%load -s MyClass,wonder_function myscript.py%load -n MyClass%load -n my_module.wonder_function
%load_ext:Load an IPython extension by its module name.
%loadpy:Alias of `%load``%loadpy` has gained some flexibility and dropped the requirement of a `.py`extension. So it has been renamed simply into %load. You can look at`%load`'s docstring for more info.
%logoff:Temporarily stop logging.You must have previously started logging.
%logon:Restart logging.This function is for restarting logging which you've temporarilystopped with %logoff. For starting logging for the first time, youmust use the %logstart function, which allows you to specify anoptional log filename.
%logstart:Start logging anywhere in a session.%logstart [-o|-r|-t|-q] [log_name [log_mode]]If no name is given, it defaults to a file named 'ipython_log.py' in yourcurrent directory, in 'rotate' mode (see below).'%logstart name' saves to file 'name' in 'backup' mode.  It saves yourhistory up to that point and then continues logging.%logstart takes a second optional parameter: logging mode. This can be oneof (note that the modes are given unquoted):appendKeep logging at the end of any existing file.backupRename any existing file to name~ and start name.globalAppend to  a single logfile in your home directory.overOverwrite any existing log.rotateCreate rotating logs: name.1~, name.2~, etc.Options:-olog also IPython's output. In this mode, all commands whichgenerate an Out[NN] prompt are recorded to the logfile, right aftertheir corresponding input line. The output lines are alwaysprepended with a '#[Out]# ' marker, so that the log remains validPython code.Since this marker is always the same, filtering only the output froma log is very easy, using for example a simple awk call::awk -F'#\[Out\]# ' '{if($2) {print $2}}' ipython_log.py-rlog 'raw' input.  Normally, IPython's logs contain the processedinput, so that user lines are logged in their final form, convertedinto valid Python.  For example, %Exit is logged as_ip.magic("Exit").  If the -r flag is given, all input is loggedexactly as typed, with no transformations applied.-tput timestamps before each input line logged (these are put incomments).-q suppress output of logstate message when logging is invoked
%logstate:Print the status of the logging system.
%logstop: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 otheroptions.
%ls:Alias for `!dir /on`
%lsmagic:List currently available magic functions.
%macro: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 validPython.  If this option is given, the raw input as typed at thecommand line is used instead.-q: quiet macro definition.  By default, a tag line is printed to indicate the macro has been created, and then the contents of the macro are printed.  If this option is given, then no printoutis produced once the macro is created.This will define a global variable called `name` which is a stringmade of joining the slices and lines you specify (n1,n2,... numbersabove) from your input history into a single string. This variableacts like an automatic function which re-executes those lines as ifyou had typed them. You just type 'name' at the prompt and the codeexecutes.The syntax for indicating input ranges is described in %history.Note: as a 'hidden' feature, you can also use traditional python slicenotation, where N:M means numbers N through M-1.For example, if your history contains (print using %hist -n )::44: x=145: y=346: z=x+y47: print x48: a=549: print 'x',x,'y',yyou can create a macro with lines 44 through 47 (included) and line 49called my_macro with::In [55]: %macro my_macro 44-47 49Now, typing `my_macro` (without quotes) will re-execute all this codein one pass.You don't need to give the line-numbers in order, and any given linenumber can appear multiple times. You can assemble macros with anylines 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 ascode 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:Print information about the magic function system.Supported formats: -latex, -brief, -rest
%matplotlib:::%matplotlib [-l] [gui]Set up matplotlib to work interactively.This function lets you activate matplotlib interactive supportat any point during an IPython session. It does not import anythinginto the interactive namespace.If you are using the inline matplotlib backend in the IPython Notebookyou can set which figure formats are enabled using the following::In [1]: from IPython.display import set_matplotlib_formatsIn [2]: set_matplotlib_formats('pdf', 'svg')The default for inline figures sets `bbox_inches` to 'tight'. This cancause discrepancies between the displayed image and the identicalimage created using `savefig`. This behavior can be disabled using the`%config` magic::In [3]: %config InlineBackend.print_figure_kwargs = {'bbox_inches':None}In addition, see the docstring of`IPython.display.set_matplotlib_formats` and`IPython.display.set_matplotlib_close` for more information onchanging additional behaviors of the inline backend.Examples--------To enable the inline backend for usage with the IPython Notebook::In [1]: %matplotlib inlineIn this case, where the matplotlib default is TkAgg::In [2]: %matplotlibUsing matplotlib backend: TkAggBut you can explicitly request a different GUI backend::In [3]: %matplotlib qtYou can list the available backends using the -l/--list option::In [4]: %matplotlib --listAvailable matplotlib backends: ['osx', 'qt4', 'qt5', 'gtk3', 'notebook', 'wx', 'qt', 'nbagg','gtk', 'tk', 'inline']positional arguments:gui         Name of the matplotlib backend to use ('agg', 'gtk', 'gtk3', 'inline', 'ipympl', 'nbagg', 'notebook','osx', 'pdf', 'ps', 'qt', 'qt4', 'qt5', 'svg', 'tk', 'widget', 'wx'). If given, the correspondingmatplotlib backend is used, otherwise it will be matplotlib's default (which you can set in yourmatplotlib config file).optional arguments:-l, --list  Show available matplotlib backends
%mkdir:Alias for `!mkdir`
%more:Show a file through the pager.Files ending in .py are syntax-highlighted.
%notebook:::%notebook filenameExport and convert IPython notebooks.This function can export the current IPython history to a notebook file.For example, to export the history to "foo.ipynb" do "%notebook foo.ipynb".The -e or --export flag is deprecated in IPython 5.2, and will beremoved in the future.positional arguments:filename  Notebook name or filename
%page:Pretty print the object and display it through a pager.%page [options] OBJECTIf no object is given, use _ (last output).Options:-r: page str(object), don't pretty-print it.
%pastebin:Upload code to dpaste.com, returning the URL.Usage:%pastebin [-d "Custom description"] 1-7The argument can be an input history range, a filename, or the name of astring or macro.Options:-d: Pass a custom description. The default will say"Pasted from IPython".
%pdb:Control the automatic calling of the pdb interactive debugger.Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called withoutargument it works as a toggle.When an exception is triggered, IPython can optionally call theinteractive pdb debugger after the traceback printout. %pdb togglesthis feature on and off.The initial state of this feature is set in your configurationfile (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 usethe %debug magic.
%pdef:Print the call signature for any callable object.If the object is a class, print the constructor information.Examples--------::In [3]: %pdef urllib.urlopenurllib.urlopen(url, data=None, proxies=None)
%pdoc:Print the docstring for an object.If the given object is a class, it will print both the class and theconstructor docstrings.
%pfile:Print (or run through pager) the file where an object is defined.The file opens at the line where the object definition begins. IPythonwill honor the environment variable PAGER if set, and otherwise willdo its best to print the file in a convenient form.If the given argument is not an object currently defined, IPython willtry to interpret it as a filename (automatically adding a .py extensionif needed). You can thus use %pfile as a syntax highlighting codeviewer.
%pinfo:Provide detailed information about an object.'%pinfo object' is just a synonym for object? or ?object.
%pinfo2:Provide extra detailed information about an object.'%pinfo2 object' is just a synonym for object?? or ??object.
%pip:Run the pip package manager within the current kernel.Usage:%pip install [pkgs]
%popd:Change to directory popped off the top of the stack.
%pprint:Toggle pretty printing on/off.
%precision: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 piIn [2]: %precision 3Out[2]: u'%.3f'In [3]: piOut[3]: 3.142In [4]: %precision %iOut[4]: u'%i'In [5]: piOut[5]: 3In [6]: %precision %eOut[6]: u'%e'In [7]: pi**10Out[7]: 9.364805e+04In [8]: %precisionOut[8]: u'%r'In [9]: pi**10Out[9]: 93648.047476082982
%prun:Run a statement through the python code profiler.Usage, in line mode:%prun [options] statementUsage, in cell mode:%%prun [options] [statement]code...code...In cell mode, the additional code lines are appended to the (possiblyempty) statement in the first line.  Cell mode allows you to easilyprofile multiline blocks without having to put them in a separatefunction.The given statement (which doesn't require quote marks) is run via thepython profiler in a manner similar to the profile.run() function.Namespaces are internally managed to work correctly; profile.runcannot be used in IPython because it makes certain assumptions aboutnamespaces which do not hold under IPython.Options:-l <limit>you can place restrictions on what or how much of theprofile gets printed. The limit value can be:* A string: only information for function names containing this stringis 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. Forexample, ``-l __init__ -l 5`` will print only the topmost 5 lines ofinformation about class constructors.-rreturn the pstats.Stats object generated by the profiling. Thisobject has all the information about the profile in it, and you canlater use it for further analysis or in other functions.-s <key>sort profile by given key. You can provide more than one keyby using the option several times: '-s key1 -s key2 -s key3...'. Thedefault sorting key is 'time'.The following is copied verbatim from the profile documentationreferenced below:When more than one key is provided, additional keys are used assecondary criteria when the there is equality in all keys selectedbefore them.Abbreviations can be used for any key names, as long as theabbreviation is unambiguous.  The following are the keys currentlydefined:============  =====================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 (placingmost time consuming items first), where as name, file, and line numbersearches are in ascending order (i.e., alphabetical). The subtledistinction between "nfl" and "stdname" is that the standard name is asort of the name as printed, which means that the embedded linenumbers get compared in an odd way.  For example, lines 3, 20, and 40would (if the file names were the same) appear in the string order"20" "3" and "40".  In contrast, "nfl" does a numeric compare of theline numbers.  In fact, sort_stats("nfl") is the same assort_stats("name", "file", "line").-T <filename>save profile results as shown on screen to a textfile. The profile is still shown on screen.-D <filename>save (via dump_stats) profile statistics to givenfilename. This data is in a format understood by the pstats module, andis generated by a call to the dump_stats() method of profileobjects. The profile is still shown on screen.-qsuppress output to the pager.  Best used with -T and/or -D above.If you want to run complete programs under the profiler's control, use``%run -p [prof_opts] filename.py [args to program]`` where prof_optscontains profiler specific options as described here.You can read the complete documentation for the profile module with::In [1]: import profile; profile.help().. versionchanged:: 7.3User variables are no longer expanded,the magic line is always left unmodified.
%psearch:Search for object in namespaces by wildcard.%psearch [options] PATTERN [OBJECT TYPE]Note: ? can be used as a synonym for %psearch, at the beginning or atthe end: both a*? and ?a* are equivalent to '%psearch a*'.  Still, therest of the command line must be unchanged (options come first), sofor example the following forms are equivalent%psearch -i a* function-i a* function??-i a* functionArguments:PATTERNwhere PATTERN is a string containing * as a wildcard similar to itsuse in a shell.  The pattern is matched in all namespaces on thesearch path. By default objects starting with a single _ are notmatched, many IPython generated objects have a singleunderscore. The default is case insensitive matching. Matching isalso done on the attributes of objects and not only on the objectsin a module.[OBJECT TYPE]Is the name of a python type from the types module. The name isgiven in lowercase without the ending type, ex. StringType iswritten string. By adding a type here only objects matching thegiven type are matched. Using all here makes the pattern match alltypes (this is the default).Options:-a: makes the pattern match even objects whose names start with asingle underscore.  These names are normally omitted from thesearch.-i/-c: make the pattern case insensitive/sensitive.  If neither ofthese options are given, the default is read from your configurationfile, with the option ``InteractiveShell.wildcards_case_sensitive``.If this option is not specified in your configuration file, IPython'sinternal default is to do a case sensitive search.-e/-s NAMESPACE: exclude/search a given namespace.  The pattern youspecify 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 shouldnot use quotes when specifying namespaces.-l: List all available object types for object matching. This functioncan be used without arguments.'Builtin' contains the python module builtin, 'user' contains alluser data, 'alias' only contain the shell aliases and no pythonobjects, '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 thesearch with -s or exclude them with -e (these options can be givenmore 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 rCase sensitive search::%psearch -c a*         list all object beginning with lower case aShow objects beginning with a single _::%psearch -a _*         list objects beginning with a single underscoreList available objects::%psearch -l            list all available object types
%psource:Print (or run through pager) the source code for an object.
%pushd:Place the current dir on stack and change directory.Usage:%pushd ['dirname']
%pwd:Return the current working directory path.Examples--------::In [9]: pwdOut[9]: '/home/tsuser/sprint/ipython'
%pycat:Show a syntax-highlighted file through a pager.This magic is similar to the cat utility, but it will assume the fileto be Python source and will show it with syntax highlighting.This magic command can either take a local filename, an url,an history range (see %history) or a macro as argument ::%pycat myscript.py%pycat 7-27%pycat myMacro%pycat http://www.example.com/myscript.py
%pylab:::%pylab [--no-import-all] [gui]Load numpy and matplotlib to work interactively.This function lets you activate pylab (matplotlib, numpy andinteractive support) at any point during an IPython session.%pylab makes the following imports::import numpyimport matplotlibfrom matplotlib import pylab, mlab, pyplotnp = numpyplt = pyplotfrom IPython.display import displayfrom IPython.core.pylabtools import figsize, getfigsfrom pylab import *from numpy import *If you pass `--no-import-all`, the last two `*` imports will be excluded.See the %matplotlib magic for more details about activating matplotlibwithout affecting the interactive namespace.positional arguments:gui              Name of the matplotlib backend to use ('agg', 'gtk', 'gtk3', 'inline', 'ipympl', 'nbagg','notebook', 'osx', 'pdf', 'ps', 'qt', 'qt4', 'qt5', 'svg', 'tk', 'widget', 'wx'). If given, thecorresponding matplotlib backend is used, otherwise it will be matplotlib's default (which you canset in your matplotlib config file).optional arguments:--no-import-all  Prevent IPython from performing ``import *`` into the interactive namespace. You can govern thedefault behavior of this flag with the InteractiveShellApp.pylab_import_all configurable.
%qtconsole:Open a qtconsole connected to this kernel.Useful for connecting a qtconsole to running notebooks, for betterdebugging.
%quickref:Show a quick reference sheet
%recall:Repeat a command, or get command to input line for editing.%recall and %rep are equivalent.- %recall (no arguments):Place a string version of last computation result (stored in thespecial '_' variable) to the next input prompt. Allows you to createelaborate command lines without using copy-paste::In[1]: l = ["hei", "vaan"]In[2]: "".join(l)Out[2]: heivaanIn[3]: %recallIn[4]: heivaan_ <== cursor blinking%recall 45Place history line 45 on the next input prompt. Use %hist to findout the number.%recall 1-4Combine the specified lines into one cell, and place it on the nextinput prompt. See %history for the slice syntax.%recall foo+barIf foo+bar can be evaluated in the user namespace, the result isplaced at the next input prompt. Otherwise, the history is searchedfor lines which contain that substring, and the most recent one isplaced at the next input prompt.
%rehashx:Update the alias table with all executable files in $PATH.rehashx explicitly checks that every entry in $PATH is a filewith execute access (os.X_OK).Under Windows, it checks executability as a match against a'|'-separated string of extensions, stored in the IPython configvariable win_exec_ext.  This defaults to 'exe|com|bat'.This function also resets the root module cache of module completer,used on slow filesystems.
%reload_ext:Reload an IPython extension by its module name.
%ren:Alias for `!ren`
%rep:Alias for `%recall`.
%rerun:Re-run previous inputBy default, you can specify ranges of input history to be repeated(as with %history). With no arguments, it will repeat the last line.Options:-l <n> : Repeat the last n lines of input, not including thecurrent command.-g foo : Repeat the most recent line which contains foo
%reset:Resets the namespace by removing all names defined by the user, ifcalled without arguments, or by removing some types of objects, suchas everything currently in IPython's In[] and Out[] containers (seethe parameters for details).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 allreferences to objects from the current session.--aggressive: Try to aggressively remove modules from sys.modules ; thismay allow you to reimport Python modules that have been updated andpick up changes, but can have unattended consequences.in : reset input historyout : reset output historydhist : reset directory historyarray : reset only variables that are NumPy arraysSee Also--------reset_selective : invoked as ``%reset_selective``Examples--------::In [6]: a = 1In [7]: aOut[7]: 1In [8]: 'a' in get_ipython().user_nsOut[8]: TrueIn [9]: %reset -fIn [1]: 'a' in get_ipython().user_nsOut[1]: FalseIn [2]: %reset -f inFlushing input historyIn [3]: %reset -f dhist inFlushing directory historyFlushing input historyNotes-----Calling this magic from clients that do not implement standard input,such as the ipython notebook interface, will reset the namespacewithout confirmation.
%reset_selective:Resets the namespace by removing names defined by the user.Input/Output history are left around in case you need them.%reset_selective [-f] regexNo action is taken if regex is not includedOptions-f : force reset without asking for confirmation.See Also--------reset : invoked as ``%reset``Examples--------We first fully reset the namespace so your output looks identical tothis example for pedagogical reasons; in practice you do not need afull reset::In [1]: %reset -fNow, 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=8In [3]: who_lsOut[3]: ['a', 'b', 'b1m', 'b2m', 'b2s', 'b3m', 'b4m', 'c']In [4]: %reset_selective -f b[2-3]mIn [5]: who_lsOut[5]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']In [6]: %reset_selective -f dIn [7]: who_lsOut[7]: ['a', 'b', 'b1m', 'b2s', 'b4m', 'c']In [8]: %reset_selective -f cIn [9]: who_lsOut[9]: ['a', 'b', 'b1m', 'b2s', 'b4m']In [10]: %reset_selective -f bIn [11]: who_lsOut[11]: ['a']Notes-----Calling this magic from clients that do not implement standard input,such as the ipython notebook interface, will reset the namespacewithout confirmation.
%rmdir:Alias for `!rmdir`
%run:Run the named file inside IPython as a program.Usage::%run [-n -i -e -G][( -t [-N<N>] | -d [-b<N>] | -p [profile options] )]( -m mod | file ) [args]Parameters after the filename are passed as command-line arguments tothe program (put in sys.argv). Then, control returns to IPython'sprompt.This is similar to running at a system prompt ``python file args``,but with the advantage of giving you IPython's tracebacks, and ofloading 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 thussees its environment as if it were being run as a stand-alone program(except for sharing global objects such as previously importedmodules). But after execution, the IPython interactive namespace getsupdated with all variables defined in the program (except for __name__and sys.argv). This allows for very convenient loading of code forinteractive work, while giving each program a 'clean sheet' to run in.Arguments are expanded using shell-like glob match.  Patterns'*', '?', '[seq]' and '[!seq]' can be used.  Additionally,tilde '~' will be expanded into user's home directory.  Unlikereal shells, quotation does not suppress expansions.  Use*two* back slashes (e.g. ``\\*``) to suppress expansions.To completely disable these expansions, you can use -G flag.On Windows systems, the use of single quotes `'` when specifying a file is not supported. Use double quotes `"`.Options:-n__name__ is NOT set to '__main__', but to the running file's namewithout extension (as python does under import).  This allows runningscripts and reloading the definitions in them without calling codeprotected by an ``if __name__ == "__main__"`` clause.-irun the file in IPython's namespace instead of an empty one. Thisis useful if you are experimenting with code written in a text editorwhich depends on variables defined interactively.-eignore sys.exit() calls or SystemExit exceptions in the scriptbeing run.  This is particularly useful if IPython is being used torun unittests, which always exit with a sys.exit() call.  In suchcases you are interested in the output of the test results, not inseeing a traceback of the unittest module.-tprint timing information at the end of the run.  IPython will giveyou an estimated CPU time consumption for your script, which underUnix uses the resource module to avoid the wraparound problems oftime.clock().  Under Unix, an estimate of time spent on system tasksis 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 torun.  The final timing report will include total and per run results.For example (testing the script uniq_stable.py)::In [1]: run -t uniq_stableIPython CPU timings (estimated):User  :    0.19597 s.System:        0.0 s.In [2]: run -t -N5 uniq_stableIPython CPU timings (estimated):Total runs performed: 5Times :      Total       Per runUser  :   0.910862 s,  0.1821724 s.System:        0.0 s,        0.0 s.-drun 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 linenumber for this automatic breakpoint to be <N> by using the -bN option(where N must be an integer). For example::%run -d -b40 myscriptwill set the first breakpoint at line 40 in myscript.py.  Note thatthe first breakpoint must be set on a line which actually doessomething (not a comment or docstring) for it to stop execution.Or you can specify a breakpoint in a different file::%run -d -b myotherfile.py:20 myscriptWhen the pdb debugger starts, you will see a (Pdb) prompt.  You mustfirst enter 'c' (without quotes) to start execution up to the firstbreakpoint.Entering 'help' gives information about the use of the debugger.  Youcan easily see pdb's full documentation with "import pdb;pdb.help()"at a prompt.-prun program under the control of the Python profiler module (whichprints a detailed report of execution times, function calls, etc).You can pass other options after -p which affect the behavior of theprofiler itself. See the docs for %prun for details.In this mode, the program's variables do NOT propagate back to theIPython interactive namespace (because they remain in the namespacewhere the profiler executes them).Internally this triggers a call to %prun, see its documentation fordetails 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[nb], the file is run as ipython script,just as if the commands were written on IPython prompt.-mspecify module name to load instead of script path. Similar tothe -m option for the python interpreter. Use this option last if youwant to combine with other %run options. Unlike the python interpreteronly source modules are allowed no .pyc or .pyo files.For example::%run -m examplewill run the example module.-Gdisable shell-like glob expansion of arguments.
%save: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 validPython.  If this option is given, the raw input as typed as thecommand line is used instead.-f: force overwrite.  If file exists, %save will prompt for overwriteunless -f is given.-a: append to the file instead of overwriting it.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, andit asks for confirmation before overwriting existing files.If `-r` option is used, the default extension is `.ipy`.
%sc:Shell capture - run shell command and capture output (DEPRECATED use !).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 documentedbelow.--%sc [options] varname=commandIPython will run the given command using commands.getoutput(), andwill then update the user's interactive namespace with a variablecalled varname, containing the value of the call.  Your command cancontain shell wildcards, pipes, etc.The '=' sign in the syntax is mandatory, and the variable name yousupply 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 beforeassigning it to the given variable.  By default the output is storedas a single string.-v: verbose.  Print the contents of the variable.In most cases you should not need to split as a list, because thereturned value is a special type of string which can automaticallyprovide its contents either as a list (split on newlines) or as aspace-separated string.  These are convenient, respectively, eitherfor sequential processing or to be passed to a shell command.For example::# Capture into variable aIn [1]: sc a=ls *py# a is a string with embedded newlinesIn [2]: aOut[2]: 'setup.py\nwin32_manual_post_install.py'# which can be seen as a list:In [3]: a.lOut[3]: ['setup.py', 'win32_manual_post_install.py']# or as a whitespace-separated string:In [4]: a.sOut[4]: 'setup.py win32_manual_post_install.py'# a.s is useful to pass as a single command line:In [5]: !wc -l $a.s146 setup.py130 win32_manual_post_install.py276 total# while the list form is useful to loop over:In [6]: for f in a.l:...:      !wc -l $f...:146 setup.py130 win32_manual_post_install.pySimilarly, the lists returned by the -l option are also special, inthe sense that you can equally invoke the .s attribute on them toautomatically get a whitespace-separated string from their contents::In [7]: sc -l b=ls *pyIn [8]: bOut[8]: ['setup.py', 'win32_manual_post_install.py']In [9]: b.sOut[9]: 'setup.py win32_manual_post_install.py'In summary, both the lists and strings used for output capture havethe 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.
%set_env:Set environment variables.  Assumptions are that either "val" is aname in the user namespace, or val is something that evaluates to astring.Usage:%set_env var val: set value for var%set_env var=val: set value for var%set_env var=$val: set value for var, using python expansion if possible
%store:Lightweight persistence for python variables.Example::In [1]: l = ['hello',10,'world']In [2]: %store lIn [3]: exit(IPython session is closed and started again...)ville@badger:~$ ipythonIn [1]: lNameError: name 'l' is not definedIn [2]: %store -rIn [3]: lOut[3]: ['hello', 10, 'world']Usage:* ``%store``          - Show list of all variables and their currentvalues* ``%store spam bar`` - Store the *current* value of the variables spamand bar to disk* ``%store -d spam``  - Remove the variable and its value from storage* ``%store -z``       - Remove all variables from storage* ``%store -r``       - Refresh all variables, aliases and directory historyfrom store (overwrite current vals)* ``%store -r spam bar`` - Refresh specified variables and aliases from store(delete current val)* ``%store foo >a.txt``  - Store value of foo to new file a.txt* ``%store foo >>a.txt`` - Append value of foo to file a.txtIt should be noted that if you change the value of a variable, youneed to %store it again if you want to persist the new value.Note also that the variables will need to be pickleable; most basicpython types can be safely %store'd.Also aliases can be %store'd across sessions.To remove an alias from the storage, use the %unalias magic.
%sx:Shell execute - run shell command and capture output (!! is short-hand).%sx commandIPython will run the given command using commands.getoutput(), andreturn the result formatted as a list (split on '\n').  Since theoutput is _returned_, it will be stored in ipython's regular outputcache Out[N] and in the '_N' automatic variables.Notes:1) If an input line begins with '!!', then %sx is automaticallyinvoked.  That is, while::!lscauses ipython to simply issue system('ls'), typing::!!lsis a shorthand equivalent to::%sx ls2) %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 possibleto process line-oriented shell output via further python commands.%sc is meant to provide much finer control, but requires moretyping.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 tosystem commands.
%system:Shell execute - run shell command and capture output (!! is short-hand).%sx commandIPython will run the given command using commands.getoutput(), andreturn the result formatted as a list (split on '\n').  Since theoutput is _returned_, it will be stored in ipython's regular outputcache Out[N] and in the '_N' automatic variables.Notes:1) If an input line begins with '!!', then %sx is automaticallyinvoked.  That is, while::!lscauses ipython to simply issue system('ls'), typing::!!lsis a shorthand equivalent to::%sx ls2) %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 possibleto process line-oriented shell output via further python commands.%sc is meant to provide much finer control, but requires moretyping.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 tosystem commands.
%tb:Print the last traceback.Optionally, specify an exception reporting mode, tuning theverbosity of the traceback. By default the currently-active exceptionmode is used. See %xmode for changing exception reporting modes.Valid modes: Plain, Context, Verbose, and Minimal.
%time:Time execution of a Python statement or expression.The CPU and wall clock times are printed, and the value of theexpression (if any) is returned.  Note that under Win32, system timeis always reported as 0, since it can not be measured.This function can be used both as a line and cell magic:- In line mode you can time a single-line statement (though multipleones can be chained with using semicolons).- In cell mode, you can time the cell body (a directlyfollowing statement raises an error).This function provides very basic timing functionality.  Use the timeitmagic for more control over the measurement... versionchanged:: 7.3User variables are no longer expanded,the magic line is always left unmodified.Examples--------::In [1]: %time 2**128CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 sWall time: 0.00Out[1]: 340282366920938463463374607431768211456LIn [2]: n = 1000000In [3]: %time sum(range(n))CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 sWall time: 1.37Out[3]: 499999500000LIn [4]: %time print 'hello world'hello worldCPU times: user 0.00 s, sys: 0.00 s, total: 0.00 sWall time: 0.00Note that the time needed by Python to compile the given expressionwill be reported if it is more than 0.1s.  In this example, theactual exponentiation is done by Python at compilation time, so whilethe expression can take a noticeable amount of time to compute, thattime is purely due to the compilation:In [5]: %time 3**9999;CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 sWall time: 0.00 sIn [6]: %time 3**999999;CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 sWall time: 0.00 sCompiler : 0.78 s
%timeit:Time execution of a Python statement or expressionUsage, in line mode:%timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] statementor in cell mode:%%timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] setup_codecodecode...Time execution of a Python statement or expression using the timeitmodule.  This function can be used both as a line and cell magic:- In line mode you can time a single-line statement (though multipleones can be chained with using semicolons).- In cell mode, the statement in the first line is used as setup code(executed but not timed) and the body of the cell is timed.  The cellbody has access to any variables created in the setup code.Options:-n<N>: execute the given statement <N> times in a loop. If <N> is notprovided, <N> is determined so as to get sufficient accuracy.-r<R>: number of repeats <R>, each consisting of <N> loops, and take thebest result.Default: 7-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 onWindows and measures wall time. On Unix, resource.getrusage is usedinstead and returns the CPU user time.-p<P>: use a precision of <P> digits to display the timing result.Default: 3-q: Quiet, do not print result.-o: return a TimeitResult that can be stored in a variable to inspectthe result in more details... versionchanged:: 7.3User variables are no longer expanded,the magic line is always left unmodified.Examples--------::In [1]: %timeit pass8.26 ns ± 0.12 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)In [2]: u = NoneIn [3]: %timeit u is None29.9 ns ± 0.643 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)In [4]: %timeit -r 4 u == NoneIn [5]: import timeIn [6]: %timeit -n1 time.sleep(2)The times reported by %timeit will be slightly higher than thosereported by the timeit.py script when variables are accessed. This isdue to the fact that %timeit executes the statement in the namespaceof the shell, compared with timeit.py, which uses a single setupstatement to import function or create variables. Generally, the biasdoes not matter as long as results from timeit.py are not mixed withthose from %timeit.
%unalias:Remove an alias
%unload_ext:Unload an IPython extension by its module name.Not all extensions can be unloaded, only those which define an``unload_ipython_extension`` function.
%who:Print all interactive variables, with some minimal formatting.If any arguments are given, only variables whose type matches one ofthese are printed.  For example::%who function strwill only list functions and strings, excluding all other types ofvariables.  To find the proper type names, simply use type(var) at acommand 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 configurationfile and things which are internal to IPython.This is deliberate, as typically you may load many modules and thepurpose of %who is to show you only what you've manually defined.Examples--------Define two variables and list them with who::In [1]: alpha = 123In [2]: beta = 'test'In [3]: %whoalpha   betaIn [4]: %who intalphaIn [5]: %who strbeta
%who_ls:Return a sorted list of all interactive variables.If arguments are given, only variables of types matching thesearguments are returned.Examples--------Define two variables and list them with who_ls::In [1]: alpha = 123In [2]: beta = 'test'In [3]: %who_lsOut[3]: ['alpha', 'beta']In [4]: %who_ls intOut[4]: ['alpha']In [5]: %who_ls strOut[5]: ['beta']
%whos:Like %who, but gives some extra information about each variable.The same type filtering of %who can be applied here.For all variables, the type is printed. Additionally it prints:- For {},[],(): their length.- For numpy arrays, a summary with shape, number ofelements, typecode and size in memory.- Everything else: a string representation, snipping their middle iftoo long.Examples--------Define two variables and list them with whos::In [1]: alpha = 123In [2]: beta = 'test'In [3]: %whosVariable   Type        Data/Info--------------------------------alpha      int         123beta       str         test
%xdel:Delete a variable, trying to clear it from anywhere thatIPython's machinery has references to it. By default, this usesthe identity of the named object in the user namespace to removereferences held under other names. The object is also removedfrom the output history.Options-n : Delete the specified name from all namespaces, withoutchecking their identity.
%xmode:Switch modes for the exception handlers.Valid modes: Plain, Context, Verbose, and Minimal.If called without arguments, acts as a toggle.When in verbose mode the value --show (and --hide) will respectively show (or hide) frames with ``__tracebackhide__ =True`` value set.
%%!:Shell execute - run shell command and capture output (!! is short-hand).%sx commandIPython will run the given command using commands.getoutput(), andreturn the result formatted as a list (split on '\n').  Since theoutput is _returned_, it will be stored in ipython's regular outputcache Out[N] and in the '_N' automatic variables.Notes:1) If an input line begins with '!!', then %sx is automaticallyinvoked.  That is, while::!lscauses ipython to simply issue system('ls'), typing::!!lsis a shorthand equivalent to::%sx ls2) %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 possibleto process line-oriented shell output via further python commands.%sc is meant to provide much finer control, but requires moretyping.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 tosystem commands.
%%HTML:Alias for `%%html`.
%%SVG:Alias for `%%svg`.
%%bash:%%bash script magicRun cells with bash in a subprocess.This is a shortcut for `%%script bash`
%%capture:::%capture [--no-stderr] [--no-stdout] [--no-display] [output]run the cell, capturing stdout, stderr, and IPython's rich display() calls.positional arguments:output        The name of the variable in which to store output. This is a utils.io.CapturedIO object withstdout/err attributes for the text of the captured output. CapturedOutput also has a show() method fordisplaying the output, and __call__ as well, so you can use that to quickly display the output. Ifunspecified, captured output is discarded.optional arguments:--no-stderr   Don't capture stderr.--no-stdout   Don't capture stdout.--no-display  Don't capture IPython's rich display.
%%cmd:%%cmd script magicRun cells with cmd in a subprocess.This is a shortcut for `%%script cmd`
%%debug:::%debug [--breakpoint FILE:LINE] [statement [statement ...]]Activate the interactive debugger.This magic command support two ways of activating debugger.One is to activate debugger before executing code.  This way, youcan set a break point, to step through the code from the point.You can use this mode by giving statements to execute and optionallya breakpoint.The other one is to activate debugger in post-mortem mode.  You canactivate this mode simply running %debug without any argument.If an exception has just occurred, this lets you inspect its stackframes interactively.  Note that this will always work only on the lasttraceback that occurred, so you must call this quickly after anexception that you wish to inspect has fired, because if another oneoccurs, it clobbers the previous one.If you want IPython to automatically do this on every exception, seethe %pdb magic for more details... versionchanged:: 7.3When running code, user variables are no longer expanded,the magic line is always left unmodified.positional arguments:statement             Code to run in debugger. You can omit this in cell magic mode.optional arguments:--breakpoint <FILE:LINE>, -b <FILE:LINE>Set break point at LINE in FILE.
%%file:Alias for `%%writefile`.
%%html:::%html [--isolated]Render the cell as a block of HTMLoptional arguments:--isolated  Annotate the cell as 'isolated'. Isolated cells are rendered inside their own <iframe> tag
%%javascript:Run the cell block of Javascript code
%%js:Run the cell block of Javascript codeAlias of `%%javascript`
%%latex:Render the cell as a block of latexThe subset of latex which is support depends on the implementation inthe client.  In the Jupyter Notebook, this magic only renders the subsetof latex defined by MathJax[here](https://docs.mathjax.org/en/v2.5-latest/tex.html).
%%markdown:Render the cell as Markdown text block
%%perl:%%perl script magicRun cells with perl in a subprocess.This is a shortcut for `%%script perl`
%%prun:Run a statement through the python code profiler.Usage, in line mode:%prun [options] statementUsage, in cell mode:%%prun [options] [statement]code...code...In cell mode, the additional code lines are appended to the (possiblyempty) statement in the first line.  Cell mode allows you to easilyprofile multiline blocks without having to put them in a separatefunction.The given statement (which doesn't require quote marks) is run via thepython profiler in a manner similar to the profile.run() function.Namespaces are internally managed to work correctly; profile.runcannot be used in IPython because it makes certain assumptions aboutnamespaces which do not hold under IPython.Options:-l <limit>you can place restrictions on what or how much of theprofile gets printed. The limit value can be:* A string: only information for function names containing this stringis 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. Forexample, ``-l __init__ -l 5`` will print only the topmost 5 lines ofinformation about class constructors.-rreturn the pstats.Stats object generated by the profiling. Thisobject has all the information about the profile in it, and you canlater use it for further analysis or in other functions.-s <key>sort profile by given key. You can provide more than one keyby using the option several times: '-s key1 -s key2 -s key3...'. Thedefault sorting key is 'time'.The following is copied verbatim from the profile documentationreferenced below:When more than one key is provided, additional keys are used assecondary criteria when the there is equality in all keys selectedbefore them.Abbreviations can be used for any key names, as long as theabbreviation is unambiguous.  The following are the keys currentlydefined:============  =====================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 (placingmost time consuming items first), where as name, file, and line numbersearches are in ascending order (i.e., alphabetical). The subtledistinction between "nfl" and "stdname" is that the standard name is asort of the name as printed, which means that the embedded linenumbers get compared in an odd way.  For example, lines 3, 20, and 40would (if the file names were the same) appear in the string order"20" "3" and "40".  In contrast, "nfl" does a numeric compare of theline numbers.  In fact, sort_stats("nfl") is the same assort_stats("name", "file", "line").-T <filename>save profile results as shown on screen to a textfile. The profile is still shown on screen.-D <filename>save (via dump_stats) profile statistics to givenfilename. This data is in a format understood by the pstats module, andis generated by a call to the dump_stats() method of profileobjects. The profile is still shown on screen.-qsuppress output to the pager.  Best used with -T and/or -D above.If you want to run complete programs under the profiler's control, use``%run -p [prof_opts] filename.py [args to program]`` where prof_optscontains profiler specific options as described here.You can read the complete documentation for the profile module with::In [1]: import profile; profile.help().. versionchanged:: 7.3User variables are no longer expanded,the magic line is always left unmodified.
%%pypy:%%pypy script magicRun cells with pypy in a subprocess.This is a shortcut for `%%script pypy`
%%python:%%python script magicRun cells with python in a subprocess.This is a shortcut for `%%script python`
%%python2:%%python2 script magicRun cells with python2 in a subprocess.This is a shortcut for `%%script python2`
%%python3:%%python3 script magicRun cells with python3 in a subprocess.This is a shortcut for `%%script python3`
%%ruby:%%ruby script magicRun cells with ruby in a subprocess.This is a shortcut for `%%script ruby`
%%script:::%shebang [--no-raise-error] [--proc PROC] [--bg] [--err ERR] [--out OUT]Run a cell via a shell commandThe `%%script` line is like the #! line of script,specifying a program (bash, perl, ruby, etc.) with which to run.The rest of the cell is run by that program.Examples--------::In [1]: %%script bash...: for i in 1 2 3; do...:   echo $i...: done123optional arguments:--no-raise-error  Whether you should raise an error message in addition to a stream on stderr if you get a nonzeroexit code.--proc PROC       The variable in which to store Popen instance. This is used only when --bg option is given.--bg              Whether to run the script in the background. If given, the only way to see the output of thecommand is with --out/err.--err ERR         The variable in which to store stderr from the script. If the script is backgrounded, this will bethe stderr *pipe*, instead of the stderr text itself and will not be autoclosed.--out OUT         The variable in which to store stdout from the script. If the script is backgrounded, this will bethe stdout *pipe*, instead of the stderr text itself and will not be auto closed.
%%sh:%%sh script magicRun cells with sh in a subprocess.This is a shortcut for `%%script sh`
%%svg:Render the cell as an SVG literal
%%sx:Shell execute - run shell command and capture output (!! is short-hand).%sx commandIPython will run the given command using commands.getoutput(), andreturn the result formatted as a list (split on '\n').  Since theoutput is _returned_, it will be stored in ipython's regular outputcache Out[N] and in the '_N' automatic variables.Notes:1) If an input line begins with '!!', then %sx is automaticallyinvoked.  That is, while::!lscauses ipython to simply issue system('ls'), typing::!!lsis a shorthand equivalent to::%sx ls2) %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 possibleto process line-oriented shell output via further python commands.%sc is meant to provide much finer control, but requires moretyping.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 tosystem commands.
%%system:Shell execute - run shell command and capture output (!! is short-hand).%sx commandIPython will run the given command using commands.getoutput(), andreturn the result formatted as a list (split on '\n').  Since theoutput is _returned_, it will be stored in ipython's regular outputcache Out[N] and in the '_N' automatic variables.Notes:1) If an input line begins with '!!', then %sx is automaticallyinvoked.  That is, while::!lscauses ipython to simply issue system('ls'), typing::!!lsis a shorthand equivalent to::%sx ls2) %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 possibleto process line-oriented shell output via further python commands.%sc is meant to provide much finer control, but requires moretyping.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 tosystem commands.
%%time:Time execution of a Python statement or expression.The CPU and wall clock times are printed, and the value of theexpression (if any) is returned.  Note that under Win32, system timeis always reported as 0, since it can not be measured.This function can be used both as a line and cell magic:- In line mode you can time a single-line statement (though multipleones can be chained with using semicolons).- In cell mode, you can time the cell body (a directlyfollowing statement raises an error).This function provides very basic timing functionality.  Use the timeitmagic for more control over the measurement... versionchanged:: 7.3User variables are no longer expanded,the magic line is always left unmodified.Examples--------::In [1]: %time 2**128CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 sWall time: 0.00Out[1]: 340282366920938463463374607431768211456LIn [2]: n = 1000000In [3]: %time sum(range(n))CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 sWall time: 1.37Out[3]: 499999500000LIn [4]: %time print 'hello world'hello worldCPU times: user 0.00 s, sys: 0.00 s, total: 0.00 sWall time: 0.00Note that the time needed by Python to compile the given expressionwill be reported if it is more than 0.1s.  In this example, theactual exponentiation is done by Python at compilation time, so whilethe expression can take a noticeable amount of time to compute, thattime is purely due to the compilation:In [5]: %time 3**9999;CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 sWall time: 0.00 sIn [6]: %time 3**999999;CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 sWall time: 0.00 sCompiler : 0.78 s
%%timeit:Time execution of a Python statement or expressionUsage, in line mode:%timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] statementor in cell mode:%%timeit [-n<N> -r<R> [-t|-c] -q -p<P> -o] setup_codecodecode...Time execution of a Python statement or expression using the timeitmodule.  This function can be used both as a line and cell magic:- In line mode you can time a single-line statement (though multipleones can be chained with using semicolons).- In cell mode, the statement in the first line is used as setup code(executed but not timed) and the body of the cell is timed.  The cellbody has access to any variables created in the setup code.Options:-n<N>: execute the given statement <N> times in a loop. If <N> is notprovided, <N> is determined so as to get sufficient accuracy.-r<R>: number of repeats <R>, each consisting of <N> loops, and take thebest result.Default: 7-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 onWindows and measures wall time. On Unix, resource.getrusage is usedinstead and returns the CPU user time.-p<P>: use a precision of <P> digits to display the timing result.Default: 3-q: Quiet, do not print result.-o: return a TimeitResult that can be stored in a variable to inspectthe result in more details... versionchanged:: 7.3User variables are no longer expanded,the magic line is always left unmodified.Examples--------::In [1]: %timeit pass8.26 ns ± 0.12 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)In [2]: u = NoneIn [3]: %timeit u is None29.9 ns ± 0.643 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)In [4]: %timeit -r 4 u == NoneIn [5]: import timeIn [6]: %timeit -n1 time.sleep(2)The times reported by %timeit will be slightly higher than thosereported by the timeit.py script when variables are accessed. This isdue to the fact that %timeit executes the statement in the namespaceof the shell, compared with timeit.py, which uses a single setupstatement to import function or create variables. Generally, the biasdoes not matter as long as results from timeit.py are not mixed withthose from %timeit.
%%writefile:::%writefile [-a] filenameWrite the contents of the cell to a file.The file will be overwritten unless the -a (--append) flag is specified.positional arguments:filename      file to writeoptional arguments:-a, --append  Append contents of the cell to an existing file. The file will be created if it does not exist.Summary of magic functions (from %lsmagic):
Available line magics:
%alias  %alias_magic  %autoawait  %autocall  %automagic  %autosave  %bookmark  %cd  %clear  %cls  %colors  %conda  %config  %connect_info  %copy  %ddir  %debug  %dhist  %dirs  %doctest_mode  %echo  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %macro  %magic  %matplotlib  %mkdir  %more  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %pip  %popd  %pprint  %precision  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %ren  %rep  %rerun  %reset  %reset_selective  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmodeAvailable cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%cmd  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefileAutomagic is ON, % prefix IS NOT needed for line magics.