|
@@
-1,3163
+1,3162
b''
|
|
1
|
.. IPython documentation master file, created by sphinx-quickstart.py on Mon Mar 24 17:01:34 2008.
|
|
1
|
.. IPython documentation master file, created by sphinx-quickstart.py on Mon Mar 24 17:01:34 2008.
|
|
2
|
You can adapt this file completely to your liking, but it should at least
|
|
2
|
You can adapt this file completely to your liking, but it should at least
|
|
3
|
contain the root 'toctree' directive.
|
|
3
|
contain the root 'toctree' directive.
|
|
4
|
|
|
4
|
|
|
5
|
=================
|
|
5
|
=================
|
|
6
|
IPython reference
|
|
6
|
IPython reference
|
|
7
|
=================
|
|
7
|
=================
|
|
8
|
|
|
8
|
|
|
9
|
.. contents::
|
|
9
|
.. contents::
|
|
10
|
|
|
10
|
|
|
11
|
.. _Command line options:
|
|
11
|
.. _command_line_options:
|
|
12
|
|
|
12
|
|
|
13
|
Command-line usage
|
|
13
|
Command-line usage
|
|
14
|
==================
|
|
14
|
==================
|
|
15
|
|
|
15
|
|
|
16
|
You start IPython with the command::
|
|
16
|
You start IPython with the command::
|
|
17
|
|
|
17
|
|
|
18
|
$ ipython [options] files
|
|
18
|
$ ipython [options] files
|
|
19
|
|
|
19
|
|
|
20
|
If invoked with no options, it executes all the files listed in sequence
|
|
20
|
If invoked with no options, it executes all the files listed in sequence
|
|
21
|
and drops you into the interpreter while still acknowledging any options
|
|
21
|
and drops you into the interpreter while still acknowledging any options
|
|
22
|
you may have set in your ipythonrc file. This behavior is different from
|
|
22
|
you may have set in your ipythonrc file. This behavior is different from
|
|
23
|
standard Python, which when called as python -i will only execute one
|
|
23
|
standard Python, which when called as python -i will only execute one
|
|
24
|
file and ignore your configuration setup.
|
|
24
|
file and ignore your configuration setup.
|
|
25
|
|
|
25
|
|
|
26
|
Please note that some of the configuration options are not available at
|
|
26
|
Please note that some of the configuration options are not available at
|
|
27
|
the command line, simply because they are not practical here. Look into
|
|
27
|
the command line, simply because they are not practical here. Look into
|
|
28
|
your ipythonrc configuration file for details on those. This file
|
|
28
|
your ipythonrc configuration file for details on those. This file
|
|
29
|
typically installed in the $HOME/.ipython directory. For Windows users,
|
|
29
|
typically installed in the $HOME/.ipython directory. For Windows users,
|
|
30
|
$HOME resolves to C:\\Documents and Settings\\YourUserName in most
|
|
30
|
$HOME resolves to C:\\Documents and Settings\\YourUserName in most
|
|
31
|
instances. In the rest of this text, we will refer to this directory as
|
|
31
|
instances. In the rest of this text, we will refer to this directory as
|
|
32
|
IPYTHONDIR.
|
|
32
|
IPYTHONDIR.
|
|
33
|
|
|
33
|
|
|
34
|
.. _Threading options:
|
|
34
|
.. _Threading options:
|
|
35
|
|
|
35
|
|
|
36
|
|
|
36
|
|
|
37
|
Special Threading Options
|
|
37
|
Special Threading Options
|
|
38
|
-------------------------
|
|
38
|
-------------------------
|
|
39
|
|
|
39
|
|
|
40
|
The following special options are ONLY valid at the beginning of the
|
|
40
|
The following special options are ONLY valid at the beginning of the
|
|
41
|
command line, and not later. This is because they control the initial-
|
|
41
|
command line, and not later. This is because they control the initial-
|
|
42
|
ization of ipython itself, before the normal option-handling mechanism
|
|
42
|
ization of ipython itself, before the normal option-handling mechanism
|
|
43
|
is active.
|
|
43
|
is active.
|
|
44
|
|
|
44
|
|
|
45
|
-gthread, -qthread, -q4thread, -wthread, -pylab:
|
|
45
|
-gthread, -qthread, -q4thread, -wthread, -pylab:
|
|
46
|
Only one of these can be given, and it can only be given as
|
|
46
|
Only one of these can be given, and it can only be given as
|
|
47
|
the first option passed to IPython (it will have no effect in
|
|
47
|
the first option passed to IPython (it will have no effect in
|
|
48
|
any other position). They provide threading support for the
|
|
48
|
any other position). They provide threading support for the
|
|
49
|
GTK, Qt (versions 3 and 4) and WXPython toolkits, and for the
|
|
49
|
GTK, Qt (versions 3 and 4) and WXPython toolkits, and for the
|
|
50
|
matplotlib library.
|
|
50
|
matplotlib library.
|
|
51
|
|
|
51
|
|
|
52
|
With any of the first four options, IPython starts running a
|
|
52
|
With any of the first four options, IPython starts running a
|
|
53
|
separate thread for the graphical toolkit's operation, so that
|
|
53
|
separate thread for the graphical toolkit's operation, so that
|
|
54
|
you can open and control graphical elements from within an
|
|
54
|
you can open and control graphical elements from within an
|
|
55
|
IPython command line, without blocking. All four provide
|
|
55
|
IPython command line, without blocking. All four provide
|
|
56
|
essentially the same functionality, respectively for GTK, Qt3,
|
|
56
|
essentially the same functionality, respectively for GTK, Qt3,
|
|
57
|
Qt4 and WXWidgets (via their Python interfaces).
|
|
57
|
Qt4 and WXWidgets (via their Python interfaces).
|
|
58
|
|
|
58
|
|
|
59
|
Note that with -wthread, you can additionally use the
|
|
59
|
Note that with -wthread, you can additionally use the
|
|
60
|
-wxversion option to request a specific version of wx to be
|
|
60
|
-wxversion option to request a specific version of wx to be
|
|
61
|
used. This requires that you have the wxversion Python module
|
|
61
|
used. This requires that you have the wxversion Python module
|
|
62
|
installed, which is part of recent wxPython distributions.
|
|
62
|
installed, which is part of recent wxPython distributions.
|
|
63
|
|
|
63
|
|
|
64
|
If -pylab is given, IPython loads special support for the mat
|
|
64
|
If -pylab is given, IPython loads special support for the mat
|
|
65
|
plotlib library (http://matplotlib.sourceforge.net), allowing
|
|
65
|
plotlib library (http://matplotlib.sourceforge.net), allowing
|
|
66
|
interactive usage of any of its backends as defined in the
|
|
66
|
interactive usage of any of its backends as defined in the
|
|
67
|
user's ~/.matplotlib/matplotlibrc file. It automatically
|
|
67
|
user's ~/.matplotlib/matplotlibrc file. It automatically
|
|
68
|
activates GTK, Qt or WX threading for IPyhton if the choice of
|
|
68
|
activates GTK, Qt or WX threading for IPyhton if the choice of
|
|
69
|
matplotlib backend requires it. It also modifies the %run
|
|
69
|
matplotlib backend requires it. It also modifies the %run
|
|
70
|
command to correctly execute (without blocking) any
|
|
70
|
command to correctly execute (without blocking) any
|
|
71
|
matplotlib-based script which calls show() at the end.
|
|
71
|
matplotlib-based script which calls show() at the end.
|
|
72
|
|
|
72
|
|
|
73
|
-tk
|
|
73
|
-tk
|
|
74
|
The -g/q/q4/wthread options, and -pylab (if matplotlib is
|
|
74
|
The -g/q/q4/wthread options, and -pylab (if matplotlib is
|
|
75
|
configured to use GTK, Qt3, Qt4 or WX), will normally block Tk
|
|
75
|
configured to use GTK, Qt3, Qt4 or WX), will normally block Tk
|
|
76
|
graphical interfaces. This means that when either GTK, Qt or WX
|
|
76
|
graphical interfaces. This means that when either GTK, Qt or WX
|
|
77
|
threading is active, any attempt to open a Tk GUI will result in a
|
|
77
|
threading is active, any attempt to open a Tk GUI will result in a
|
|
78
|
dead window, and possibly cause the Python interpreter to crash.
|
|
78
|
dead window, and possibly cause the Python interpreter to crash.
|
|
79
|
An extra option, -tk, is available to address this issue. It can
|
|
79
|
An extra option, -tk, is available to address this issue. It can
|
|
80
|
only be given as a second option after any of the above (-gthread,
|
|
80
|
only be given as a second option after any of the above (-gthread,
|
|
81
|
-wthread or -pylab).
|
|
81
|
-wthread or -pylab).
|
|
82
|
|
|
82
|
|
|
83
|
If -tk is given, IPython will try to coordinate Tk threading
|
|
83
|
If -tk is given, IPython will try to coordinate Tk threading
|
|
84
|
with GTK, Qt or WX. This is however potentially unreliable, and
|
|
84
|
with GTK, Qt or WX. This is however potentially unreliable, and
|
|
85
|
you will have to test on your platform and Python configuration to
|
|
85
|
you will have to test on your platform and Python configuration to
|
|
86
|
determine whether it works for you. Debian users have reported
|
|
86
|
determine whether it works for you. Debian users have reported
|
|
87
|
success, apparently due to the fact that Debian builds all of Tcl,
|
|
87
|
success, apparently due to the fact that Debian builds all of Tcl,
|
|
88
|
Tk, Tkinter and Python with pthreads support. Under other Linux
|
|
88
|
Tk, Tkinter and Python with pthreads support. Under other Linux
|
|
89
|
environments (such as Fedora Core 2/3), this option has caused
|
|
89
|
environments (such as Fedora Core 2/3), this option has caused
|
|
90
|
random crashes and lockups of the Python interpreter. Under other
|
|
90
|
random crashes and lockups of the Python interpreter. Under other
|
|
91
|
operating systems (Mac OSX and Windows), you'll need to try it to
|
|
91
|
operating systems (Mac OSX and Windows), you'll need to try it to
|
|
92
|
find out, since currently no user reports are available.
|
|
92
|
find out, since currently no user reports are available.
|
|
93
|
|
|
93
|
|
|
94
|
There is unfortunately no way for IPython to determine at run time
|
|
94
|
There is unfortunately no way for IPython to determine at run time
|
|
95
|
whether -tk will work reliably or not, so you will need to do some
|
|
95
|
whether -tk will work reliably or not, so you will need to do some
|
|
96
|
experiments before relying on it for regular work.
|
|
96
|
experiments before relying on it for regular work.
|
|
97
|
|
|
97
|
|
|
98
|
|
|
98
|
|
|
99
|
|
|
99
|
|
|
100
|
Regular Options
|
|
100
|
Regular Options
|
|
101
|
---------------
|
|
101
|
---------------
|
|
102
|
|
|
102
|
|
|
103
|
After the above threading options have been given, regular options can
|
|
103
|
After the above threading options have been given, regular options can
|
|
104
|
follow in any order. All options can be abbreviated to their shortest
|
|
104
|
follow in any order. All options can be abbreviated to their shortest
|
|
105
|
non-ambiguous form and are case-sensitive. One or two dashes can be
|
|
105
|
non-ambiguous form and are case-sensitive. One or two dashes can be
|
|
106
|
used. Some options have an alternate short form, indicated after a ``|``.
|
|
106
|
used. Some options have an alternate short form, indicated after a ``|``.
|
|
107
|
|
|
107
|
|
|
108
|
Most options can also be set from your ipythonrc configuration file. See
|
|
108
|
Most options can also be set from your ipythonrc configuration file. See
|
|
109
|
the provided example for more details on what the options do. Options
|
|
109
|
the provided example for more details on what the options do. Options
|
|
110
|
given at the command line override the values set in the ipythonrc file.
|
|
110
|
given at the command line override the values set in the ipythonrc file.
|
|
111
|
|
|
111
|
|
|
112
|
All options with a [no] prepended can be specified in negated form
|
|
112
|
All options with a [no] prepended can be specified in negated form
|
|
113
|
(-nooption instead of -option) to turn the feature off.
|
|
113
|
(-nooption instead of -option) to turn the feature off.
|
|
114
|
|
|
114
|
|
|
115
|
-help print a help message and exit.
|
|
115
|
-help print a help message and exit.
|
|
116
|
|
|
116
|
|
|
117
|
-pylab
|
|
117
|
-pylab
|
|
118
|
this can only be given as the first option passed to IPython
|
|
118
|
this can only be given as the first option passed to IPython
|
|
119
|
(it will have no effect in any other position). It adds
|
|
119
|
(it will have no effect in any other position). It adds
|
|
120
|
special support for the matplotlib library
|
|
120
|
special support for the matplotlib library
|
|
121
|
(http://matplotlib.sourceforge.ne), allowing interactive usage
|
|
121
|
(http://matplotlib.sourceforge.ne), allowing interactive usage
|
|
122
|
of any of its backends as defined in the user's .matplotlibrc
|
|
122
|
of any of its backends as defined in the user's .matplotlibrc
|
|
123
|
file. It automatically activates GTK or WX threading for
|
|
123
|
file. It automatically activates GTK or WX threading for
|
|
124
|
IPyhton if the choice of matplotlib backend requires it. It
|
|
124
|
IPyhton if the choice of matplotlib backend requires it. It
|
|
125
|
also modifies the %run command to correctly execute (without
|
|
125
|
also modifies the %run command to correctly execute (without
|
|
126
|
blocking) any matplotlib-based script which calls show() at
|
|
126
|
blocking) any matplotlib-based script which calls show() at
|
|
127
|
the end. See `Matplotlib support`_ for more details.
|
|
127
|
the end. See `Matplotlib support`_ for more details.
|
|
128
|
|
|
128
|
|
|
129
|
-autocall <val>
|
|
129
|
-autocall <val>
|
|
130
|
Make IPython automatically call any callable object even if you
|
|
130
|
Make IPython automatically call any callable object even if you
|
|
131
|
didn't type explicit parentheses. For example, 'str 43' becomes
|
|
131
|
didn't type explicit parentheses. For example, 'str 43' becomes
|
|
132
|
'str(43)' automatically. The value can be '0' to disable the feature,
|
|
132
|
'str(43)' automatically. The value can be '0' to disable the feature,
|
|
133
|
'1' for smart autocall, where it is not applied if there are no more
|
|
133
|
'1' for smart autocall, where it is not applied if there are no more
|
|
134
|
arguments on the line, and '2' for full autocall, where all callable
|
|
134
|
arguments on the line, and '2' for full autocall, where all callable
|
|
135
|
objects are automatically called (even if no arguments are
|
|
135
|
objects are automatically called (even if no arguments are
|
|
136
|
present). The default is '1'.
|
|
136
|
present). The default is '1'.
|
|
137
|
|
|
137
|
|
|
138
|
-[no]autoindent
|
|
138
|
-[no]autoindent
|
|
139
|
Turn automatic indentation on/off.
|
|
139
|
Turn automatic indentation on/off.
|
|
140
|
|
|
140
|
|
|
141
|
-[no]automagic
|
|
141
|
-[no]automagic
|
|
142
|
make magic commands automatic (without needing their first character
|
|
142
|
make magic commands automatic (without needing their first character
|
|
143
|
to be %). Type %magic at the IPython prompt for more information.
|
|
143
|
to be %). Type %magic at the IPython prompt for more information.
|
|
144
|
|
|
144
|
|
|
145
|
-[no]autoedit_syntax
|
|
145
|
-[no]autoedit_syntax
|
|
146
|
When a syntax error occurs after editing a file, automatically
|
|
146
|
When a syntax error occurs after editing a file, automatically
|
|
147
|
open the file to the trouble causing line for convenient
|
|
147
|
open the file to the trouble causing line for convenient
|
|
148
|
fixing.
|
|
148
|
fixing.
|
|
149
|
|
|
149
|
|
|
150
|
-[no]banner Print the initial information banner (default on).
|
|
150
|
-[no]banner Print the initial information banner (default on).
|
|
151
|
|
|
151
|
|
|
152
|
-c <command>
|
|
152
|
-c <command>
|
|
153
|
execute the given command string. This is similar to the -c
|
|
153
|
execute the given command string. This is similar to the -c
|
|
154
|
option in the normal Python interpreter.
|
|
154
|
option in the normal Python interpreter.
|
|
155
|
|
|
155
|
|
|
156
|
-cache_size, cs <n>
|
|
156
|
-cache_size, cs <n>
|
|
157
|
size of the output cache (maximum number of entries to hold in
|
|
157
|
size of the output cache (maximum number of entries to hold in
|
|
158
|
memory). The default is 1000, you can change it permanently in your
|
|
158
|
memory). The default is 1000, you can change it permanently in your
|
|
159
|
config file. Setting it to 0 completely disables the caching system,
|
|
159
|
config file. Setting it to 0 completely disables the caching system,
|
|
160
|
and the minimum value accepted is 20 (if you provide a value less than
|
|
160
|
and the minimum value accepted is 20 (if you provide a value less than
|
|
161
|
20, it is reset to 0 and a warning is issued) This limit is defined
|
|
161
|
20, it is reset to 0 and a warning is issued) This limit is defined
|
|
162
|
because otherwise you'll spend more time re-flushing a too small cache
|
|
162
|
because otherwise you'll spend more time re-flushing a too small cache
|
|
163
|
than working.
|
|
163
|
than working.
|
|
164
|
|
|
164
|
|
|
165
|
-classic, cl
|
|
165
|
-classic, cl
|
|
166
|
Gives IPython a similar feel to the classic Python
|
|
166
|
Gives IPython a similar feel to the classic Python
|
|
167
|
prompt.
|
|
167
|
prompt.
|
|
168
|
|
|
168
|
|
|
169
|
-colors <scheme>
|
|
169
|
-colors <scheme>
|
|
170
|
Color scheme for prompts and exception reporting. Currently
|
|
170
|
Color scheme for prompts and exception reporting. Currently
|
|
171
|
implemented: NoColor, Linux and LightBG.
|
|
171
|
implemented: NoColor, Linux and LightBG.
|
|
172
|
|
|
172
|
|
|
173
|
-[no]color_info
|
|
173
|
-[no]color_info
|
|
174
|
IPython can display information about objects via a set of functions,
|
|
174
|
IPython can display information about objects via a set of functions,
|
|
175
|
and optionally can use colors for this, syntax highlighting source
|
|
175
|
and optionally can use colors for this, syntax highlighting source
|
|
176
|
code and various other elements. However, because this information is
|
|
176
|
code and various other elements. However, because this information is
|
|
177
|
passed through a pager (like 'less') and many pagers get confused with
|
|
177
|
passed through a pager (like 'less') and many pagers get confused with
|
|
178
|
color codes, this option is off by default. You can test it and turn
|
|
178
|
color codes, this option is off by default. You can test it and turn
|
|
179
|
it on permanently in your ipythonrc file if it works for you. As a
|
|
179
|
it on permanently in your ipythonrc file if it works for you. As a
|
|
180
|
reference, the 'less' pager supplied with Mandrake 8.2 works ok, but
|
|
180
|
reference, the 'less' pager supplied with Mandrake 8.2 works ok, but
|
|
181
|
that in RedHat 7.2 doesn't.
|
|
181
|
that in RedHat 7.2 doesn't.
|
|
182
|
|
|
182
|
|
|
183
|
Test it and turn it on permanently if it works with your
|
|
183
|
Test it and turn it on permanently if it works with your
|
|
184
|
system. The magic function %color_info allows you to toggle this
|
|
184
|
system. The magic function %color_info allows you to toggle this
|
|
185
|
interactively for testing.
|
|
185
|
interactively for testing.
|
|
186
|
|
|
186
|
|
|
187
|
-[no]debug
|
|
187
|
-[no]debug
|
|
188
|
Show information about the loading process. Very useful to pin down
|
|
188
|
Show information about the loading process. Very useful to pin down
|
|
189
|
problems with your configuration files or to get details about
|
|
189
|
problems with your configuration files or to get details about
|
|
190
|
session restores.
|
|
190
|
session restores.
|
|
191
|
|
|
191
|
|
|
192
|
-[no]deep_reload:
|
|
192
|
-[no]deep_reload:
|
|
193
|
IPython can use the deep_reload module which reloads changes in
|
|
193
|
IPython can use the deep_reload module which reloads changes in
|
|
194
|
modules recursively (it replaces the reload() function, so you don't
|
|
194
|
modules recursively (it replaces the reload() function, so you don't
|
|
195
|
need to change anything to use it). deep_reload() forces a full
|
|
195
|
need to change anything to use it). deep_reload() forces a full
|
|
196
|
reload of modules whose code may have changed, which the default
|
|
196
|
reload of modules whose code may have changed, which the default
|
|
197
|
reload() function does not.
|
|
197
|
reload() function does not.
|
|
198
|
|
|
198
|
|
|
199
|
When deep_reload is off, IPython will use the normal reload(),
|
|
199
|
When deep_reload is off, IPython will use the normal reload(),
|
|
200
|
but deep_reload will still be available as dreload(). This
|
|
200
|
but deep_reload will still be available as dreload(). This
|
|
201
|
feature is off by default [which means that you have both
|
|
201
|
feature is off by default [which means that you have both
|
|
202
|
normal reload() and dreload()].
|
|
202
|
normal reload() and dreload()].
|
|
203
|
|
|
203
|
|
|
204
|
-editor <name>
|
|
204
|
-editor <name>
|
|
205
|
Which editor to use with the %edit command. By default,
|
|
205
|
Which editor to use with the %edit command. By default,
|
|
206
|
IPython will honor your EDITOR environment variable (if not
|
|
206
|
IPython will honor your EDITOR environment variable (if not
|
|
207
|
set, vi is the Unix default and notepad the Windows one).
|
|
207
|
set, vi is the Unix default and notepad the Windows one).
|
|
208
|
Since this editor is invoked on the fly by IPython and is
|
|
208
|
Since this editor is invoked on the fly by IPython and is
|
|
209
|
meant for editing small code snippets, you may want to use a
|
|
209
|
meant for editing small code snippets, you may want to use a
|
|
210
|
small, lightweight editor here (in case your default EDITOR is
|
|
210
|
small, lightweight editor here (in case your default EDITOR is
|
|
211
|
something like Emacs).
|
|
211
|
something like Emacs).
|
|
212
|
|
|
212
|
|
|
213
|
-ipythondir <name>
|
|
213
|
-ipythondir <name>
|
|
214
|
name of your IPython configuration directory IPYTHONDIR. This
|
|
214
|
name of your IPython configuration directory IPYTHONDIR. This
|
|
215
|
can also be specified through the environment variable
|
|
215
|
can also be specified through the environment variable
|
|
216
|
IPYTHONDIR.
|
|
216
|
IPYTHONDIR.
|
|
217
|
|
|
217
|
|
|
218
|
-log, l
|
|
218
|
-log, l
|
|
219
|
generate a log file of all input. The file is named
|
|
219
|
generate a log file of all input. The file is named
|
|
220
|
ipython_log.py in your current directory (which prevents logs
|
|
220
|
ipython_log.py in your current directory (which prevents logs
|
|
221
|
from multiple IPython sessions from trampling each other). You
|
|
221
|
from multiple IPython sessions from trampling each other). You
|
|
222
|
can use this to later restore a session by loading your
|
|
222
|
can use this to later restore a session by loading your
|
|
223
|
logfile as a file to be executed with option -logplay (see
|
|
223
|
logfile as a file to be executed with option -logplay (see
|
|
224
|
below).
|
|
224
|
below).
|
|
225
|
|
|
225
|
|
|
226
|
-logfile, lf <name> specify the name of your logfile.
|
|
226
|
-logfile, lf <name> specify the name of your logfile.
|
|
227
|
|
|
227
|
|
|
228
|
-logplay, lp <name>
|
|
228
|
-logplay, lp <name>
|
|
229
|
|
|
229
|
|
|
230
|
you can replay a previous log. For restoring a session as close as
|
|
230
|
you can replay a previous log. For restoring a session as close as
|
|
231
|
possible to the state you left it in, use this option (don't just run
|
|
231
|
possible to the state you left it in, use this option (don't just run
|
|
232
|
the logfile). With -logplay, IPython will try to reconstruct the
|
|
232
|
the logfile). With -logplay, IPython will try to reconstruct the
|
|
233
|
previous working environment in full, not just execute the commands in
|
|
233
|
previous working environment in full, not just execute the commands in
|
|
234
|
the logfile.
|
|
234
|
the logfile.
|
|
235
|
|
|
235
|
|
|
236
|
When a session is restored, logging is automatically turned on
|
|
236
|
When a session is restored, logging is automatically turned on
|
|
237
|
again with the name of the logfile it was invoked with (it is
|
|
237
|
again with the name of the logfile it was invoked with (it is
|
|
238
|
read from the log header). So once you've turned logging on for
|
|
238
|
read from the log header). So once you've turned logging on for
|
|
239
|
a session, you can quit IPython and reload it as many times as
|
|
239
|
a session, you can quit IPython and reload it as many times as
|
|
240
|
you want and it will continue to log its history and restore
|
|
240
|
you want and it will continue to log its history and restore
|
|
241
|
from the beginning every time.
|
|
241
|
from the beginning every time.
|
|
242
|
|
|
242
|
|
|
243
|
Caveats: there are limitations in this option. The history
|
|
243
|
Caveats: there are limitations in this option. The history
|
|
244
|
variables _i*,_* and _dh don't get restored properly. In the
|
|
244
|
variables _i*,_* and _dh don't get restored properly. In the
|
|
245
|
future we will try to implement full session saving by writing
|
|
245
|
future we will try to implement full session saving by writing
|
|
246
|
and retrieving a 'snapshot' of the memory state of IPython. But
|
|
246
|
and retrieving a 'snapshot' of the memory state of IPython. But
|
|
247
|
our first attempts failed because of inherent limitations of
|
|
247
|
our first attempts failed because of inherent limitations of
|
|
248
|
Python's Pickle module, so this may have to wait.
|
|
248
|
Python's Pickle module, so this may have to wait.
|
|
249
|
|
|
249
|
|
|
250
|
-[no]messages
|
|
250
|
-[no]messages
|
|
251
|
Print messages which IPython collects about its startup
|
|
251
|
Print messages which IPython collects about its startup
|
|
252
|
process (default on).
|
|
252
|
process (default on).
|
|
253
|
|
|
253
|
|
|
254
|
-[no]pdb
|
|
254
|
-[no]pdb
|
|
255
|
Automatically call the pdb debugger after every uncaught
|
|
255
|
Automatically call the pdb debugger after every uncaught
|
|
256
|
exception. If you are used to debugging using pdb, this puts
|
|
256
|
exception. If you are used to debugging using pdb, this puts
|
|
257
|
you automatically inside of it after any call (either in
|
|
257
|
you automatically inside of it after any call (either in
|
|
258
|
IPython or in code called by it) which triggers an exception
|
|
258
|
IPython or in code called by it) which triggers an exception
|
|
259
|
which goes uncaught.
|
|
259
|
which goes uncaught.
|
|
260
|
|
|
260
|
|
|
261
|
-pydb
|
|
261
|
-pydb
|
|
262
|
Makes IPython use the third party "pydb" package as debugger,
|
|
262
|
Makes IPython use the third party "pydb" package as debugger,
|
|
263
|
instead of pdb. Requires that pydb is installed.
|
|
263
|
instead of pdb. Requires that pydb is installed.
|
|
264
|
|
|
264
|
|
|
265
|
-[no]pprint
|
|
265
|
-[no]pprint
|
|
266
|
ipython can optionally use the pprint (pretty printer) module
|
|
266
|
ipython can optionally use the pprint (pretty printer) module
|
|
267
|
for displaying results. pprint tends to give a nicer display
|
|
267
|
for displaying results. pprint tends to give a nicer display
|
|
268
|
of nested data structures. If you like it, you can turn it on
|
|
268
|
of nested data structures. If you like it, you can turn it on
|
|
269
|
permanently in your config file (default off).
|
|
269
|
permanently in your config file (default off).
|
|
270
|
|
|
270
|
|
|
271
|
-profile, p <name>
|
|
271
|
-profile, p <name>
|
|
272
|
|
|
272
|
|
|
273
|
assume that your config file is ipythonrc-<name> or
|
|
273
|
assume that your config file is ipythonrc-<name> or
|
|
274
|
ipy_profile_<name>.py (looks in current dir first, then in
|
|
274
|
ipy_profile_<name>.py (looks in current dir first, then in
|
|
275
|
IPYTHONDIR). This is a quick way to keep and load multiple
|
|
275
|
IPYTHONDIR). This is a quick way to keep and load multiple
|
|
276
|
config files for different tasks, especially if you use the
|
|
276
|
config files for different tasks, especially if you use the
|
|
277
|
include option of config files. You can keep a basic
|
|
277
|
include option of config files. You can keep a basic
|
|
278
|
IPYTHONDIR/ipythonrc file and then have other 'profiles' which
|
|
278
|
IPYTHONDIR/ipythonrc file and then have other 'profiles' which
|
|
279
|
include this one and load extra things for particular
|
|
279
|
include this one and load extra things for particular
|
|
280
|
tasks. For example:
|
|
280
|
tasks. For example:
|
|
281
|
|
|
281
|
|
|
282
|
1. $HOME/.ipython/ipythonrc : load basic things you always want.
|
|
282
|
1. $HOME/.ipython/ipythonrc : load basic things you always want.
|
|
283
|
2. $HOME/.ipython/ipythonrc-math : load (1) and basic math-related modules.
|
|
283
|
2. $HOME/.ipython/ipythonrc-math : load (1) and basic math-related modules.
|
|
284
|
3. $HOME/.ipython/ipythonrc-numeric : load (1) and Numeric and plotting modules.
|
|
284
|
3. $HOME/.ipython/ipythonrc-numeric : load (1) and Numeric and plotting modules.
|
|
285
|
|
|
285
|
|
|
286
|
Since it is possible to create an endless loop by having
|
|
286
|
Since it is possible to create an endless loop by having
|
|
287
|
circular file inclusions, IPython will stop if it reaches 15
|
|
287
|
circular file inclusions, IPython will stop if it reaches 15
|
|
288
|
recursive inclusions.
|
|
288
|
recursive inclusions.
|
|
289
|
|
|
289
|
|
|
290
|
-prompt_in1, pi1 <string>
|
|
290
|
-prompt_in1, pi1 <string>
|
|
291
|
Specify the string used for input prompts. Note that if you
|
|
291
|
|
|
292
|
are using numbered prompts, the number is represented with a
|
|
292
|
Specify the string used for input prompts. Note that if you are using
|
|
293
|
'\#' in the string. Don't forget to quote strings with spaces
|
|
293
|
numbered prompts, the number is represented with a '\#' in the
|
|
294
|
embedded in them. Default: 'In [\#]:'. Sec. Prompts_
|
|
294
|
string. Don't forget to quote strings with spaces embedded in
|
|
295
|
discusses in detail all the available escapes to customize
|
|
295
|
them. Default: 'In [\#]:'. The :ref:`prompts section <prompts>`
|
|
296
|
your prompts.
|
|
296
|
discusses in detail all the available escapes to customize your
|
|
|
|
|
297
|
prompts.
|
|
297
|
|
|
298
|
|
|
298
|
-prompt_in2, pi2 <string>
|
|
299
|
-prompt_in2, pi2 <string>
|
|
299
|
Similar to the previous option, but used for the continuation
|
|
300
|
Similar to the previous option, but used for the continuation
|
|
300
|
prompts. The special sequence '\D' is similar to '\#', but
|
|
301
|
prompts. The special sequence '\D' is similar to '\#', but
|
|
301
|
with all digits replaced dots (so you can have your
|
|
302
|
with all digits replaced dots (so you can have your
|
|
302
|
continuation prompt aligned with your input prompt). Default:
|
|
303
|
continuation prompt aligned with your input prompt). Default:
|
|
303
|
' .\D.:' (note three spaces at the start for alignment with
|
|
304
|
' .\D.:' (note three spaces at the start for alignment with
|
|
304
|
'In [\#]').
|
|
305
|
'In [\#]').
|
|
305
|
|
|
306
|
|
|
306
|
-prompt_out,po <string>
|
|
307
|
-prompt_out,po <string>
|
|
307
|
String used for output prompts, also uses numbers like
|
|
308
|
String used for output prompts, also uses numbers like
|
|
308
|
prompt_in1. Default: 'Out[\#]:'
|
|
309
|
prompt_in1. Default: 'Out[\#]:'
|
|
309
|
|
|
310
|
|
|
310
|
-quick start in bare bones mode (no config file loaded).
|
|
311
|
-quick start in bare bones mode (no config file loaded).
|
|
311
|
|
|
312
|
|
|
312
|
-rcfile <name>
|
|
313
|
-rcfile <name>
|
|
313
|
name of your IPython resource configuration file. Normally
|
|
314
|
name of your IPython resource configuration file. Normally
|
|
314
|
IPython loads ipythonrc (from current directory) or
|
|
315
|
IPython loads ipythonrc (from current directory) or
|
|
315
|
IPYTHONDIR/ipythonrc.
|
|
316
|
IPYTHONDIR/ipythonrc.
|
|
316
|
|
|
317
|
|
|
317
|
If the loading of your config file fails, IPython starts with
|
|
318
|
If the loading of your config file fails, IPython starts with
|
|
318
|
a bare bones configuration (no modules loaded at all).
|
|
319
|
a bare bones configuration (no modules loaded at all).
|
|
319
|
|
|
320
|
|
|
320
|
-[no]readline
|
|
321
|
-[no]readline
|
|
321
|
use the readline library, which is needed to support name
|
|
322
|
use the readline library, which is needed to support name
|
|
322
|
completion and command history, among other things. It is
|
|
323
|
completion and command history, among other things. It is
|
|
323
|
enabled by default, but may cause problems for users of
|
|
324
|
enabled by default, but may cause problems for users of
|
|
324
|
X/Emacs in Python comint or shell buffers.
|
|
325
|
X/Emacs in Python comint or shell buffers.
|
|
325
|
|
|
326
|
|
|
326
|
Note that X/Emacs 'eterm' buffers (opened with M-x term) support
|
|
327
|
Note that X/Emacs 'eterm' buffers (opened with M-x term) support
|
|
327
|
IPython's readline and syntax coloring fine, only 'emacs' (M-x
|
|
328
|
IPython's readline and syntax coloring fine, only 'emacs' (M-x
|
|
328
|
shell and C-c !) buffers do not.
|
|
329
|
shell and C-c !) buffers do not.
|
|
329
|
|
|
330
|
|
|
330
|
-screen_length, sl <n>
|
|
331
|
-screen_length, sl <n>
|
|
331
|
number of lines of your screen. This is used to control
|
|
332
|
number of lines of your screen. This is used to control
|
|
332
|
printing of very long strings. Strings longer than this number
|
|
333
|
printing of very long strings. Strings longer than this number
|
|
333
|
of lines will be sent through a pager instead of directly
|
|
334
|
of lines will be sent through a pager instead of directly
|
|
334
|
printed.
|
|
335
|
printed.
|
|
335
|
|
|
336
|
|
|
336
|
The default value for this is 0, which means IPython will
|
|
337
|
The default value for this is 0, which means IPython will
|
|
337
|
auto-detect your screen size every time it needs to print certain
|
|
338
|
auto-detect your screen size every time it needs to print certain
|
|
338
|
potentially long strings (this doesn't change the behavior of the
|
|
339
|
potentially long strings (this doesn't change the behavior of the
|
|
339
|
'print' keyword, it's only triggered internally). If for some
|
|
340
|
'print' keyword, it's only triggered internally). If for some
|
|
340
|
reason this isn't working well (it needs curses support), specify
|
|
341
|
reason this isn't working well (it needs curses support), specify
|
|
341
|
it yourself. Otherwise don't change the default.
|
|
342
|
it yourself. Otherwise don't change the default.
|
|
342
|
|
|
343
|
|
|
343
|
-separate_in, si <string>
|
|
344
|
-separate_in, si <string>
|
|
344
|
|
|
345
|
|
|
345
|
separator before input prompts.
|
|
346
|
separator before input prompts.
|
|
346
|
Default: '\n'
|
|
347
|
Default: '\n'
|
|
347
|
|
|
348
|
|
|
348
|
-separate_out, so <string>
|
|
349
|
-separate_out, so <string>
|
|
349
|
separator before output prompts.
|
|
350
|
separator before output prompts.
|
|
350
|
Default: nothing.
|
|
351
|
Default: nothing.
|
|
351
|
|
|
352
|
|
|
352
|
-separate_out2, so2
|
|
353
|
-separate_out2, so2
|
|
353
|
separator after output prompts.
|
|
354
|
separator after output prompts.
|
|
354
|
Default: nothing.
|
|
355
|
Default: nothing.
|
|
355
|
For these three options, use the value 0 to specify no separator.
|
|
356
|
For these three options, use the value 0 to specify no separator.
|
|
356
|
|
|
357
|
|
|
357
|
-nosep
|
|
358
|
-nosep
|
|
358
|
shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2
|
|
359
|
shorthand for '-SeparateIn 0 -SeparateOut 0 -SeparateOut2
|
|
359
|
0'. Simply removes all input/output separators.
|
|
360
|
0'. Simply removes all input/output separators.
|
|
360
|
|
|
361
|
|
|
361
|
-upgrade
|
|
362
|
-upgrade
|
|
362
|
allows you to upgrade your IPYTHONDIR configuration when you
|
|
363
|
allows you to upgrade your IPYTHONDIR configuration when you
|
|
363
|
install a new version of IPython. Since new versions may
|
|
364
|
install a new version of IPython. Since new versions may
|
|
364
|
include new command line options or example files, this copies
|
|
365
|
include new command line options or example files, this copies
|
|
365
|
updated ipythonrc-type files. However, it backs up (with a
|
|
366
|
updated ipythonrc-type files. However, it backs up (with a
|
|
366
|
.old extension) all files which it overwrites so that you can
|
|
367
|
.old extension) all files which it overwrites so that you can
|
|
367
|
merge back any customizations you might have in your personal
|
|
368
|
merge back any customizations you might have in your personal
|
|
368
|
files. Note that you should probably use %upgrade instead,
|
|
369
|
files. Note that you should probably use %upgrade instead,
|
|
369
|
it's a safer alternative.
|
|
370
|
it's a safer alternative.
|
|
370
|
|
|
371
|
|
|
371
|
|
|
372
|
|
|
372
|
-Version print version information and exit.
|
|
373
|
-Version print version information and exit.
|
|
373
|
|
|
374
|
|
|
374
|
-wxversion <string>
|
|
375
|
-wxversion <string>
|
|
375
|
Select a specific version of wxPython (used in conjunction
|
|
376
|
Select a specific version of wxPython (used in conjunction
|
|
376
|
with -wthread). Requires the wxversion module, part of recent
|
|
377
|
with -wthread). Requires the wxversion module, part of recent
|
|
377
|
wxPython distributions
|
|
378
|
wxPython distributions
|
|
378
|
|
|
379
|
|
|
379
|
-xmode <modename>
|
|
380
|
-xmode <modename>
|
|
380
|
|
|
381
|
|
|
381
|
Mode for exception reporting.
|
|
382
|
Mode for exception reporting.
|
|
382
|
|
|
383
|
|
|
383
|
Valid modes: Plain, Context and Verbose.
|
|
384
|
Valid modes: Plain, Context and Verbose.
|
|
384
|
|
|
385
|
|
|
385
|
* Plain: similar to python's normal traceback printing.
|
|
386
|
* Plain: similar to python's normal traceback printing.
|
|
386
|
* Context: prints 5 lines of context source code around each
|
|
387
|
* Context: prints 5 lines of context source code around each
|
|
387
|
line in the traceback.
|
|
388
|
line in the traceback.
|
|
388
|
* Verbose: similar to Context, but additionally prints the
|
|
389
|
* Verbose: similar to Context, but additionally prints the
|
|
389
|
variables currently visible where the exception happened
|
|
390
|
variables currently visible where the exception happened
|
|
390
|
(shortening their strings if too long). This can potentially be
|
|
391
|
(shortening their strings if too long). This can potentially be
|
|
391
|
very slow, if you happen to have a huge data structure whose
|
|
392
|
very slow, if you happen to have a huge data structure whose
|
|
392
|
string representation is complex to compute. Your computer may
|
|
393
|
string representation is complex to compute. Your computer may
|
|
393
|
appear to freeze for a while with cpu usage at 100%. If this
|
|
394
|
appear to freeze for a while with cpu usage at 100%. If this
|
|
394
|
occurs, you can cancel the traceback with Ctrl-C (maybe hitting it
|
|
395
|
occurs, you can cancel the traceback with Ctrl-C (maybe hitting it
|
|
395
|
more than once).
|
|
396
|
more than once).
|
|
396
|
|
|
397
|
|
|
397
|
Interactive use
|
|
398
|
Interactive use
|
|
398
|
===============
|
|
399
|
===============
|
|
399
|
|
|
400
|
|
|
400
|
Warning: IPython relies on the existence of a global variable called
|
|
401
|
Warning: IPython relies on the existence of a global variable called
|
|
401
|
_ip which controls the shell itself. If you redefine _ip to anything,
|
|
402
|
_ip which controls the shell itself. If you redefine _ip to anything,
|
|
402
|
bizarre behavior will quickly occur.
|
|
403
|
bizarre behavior will quickly occur.
|
|
403
|
|
|
404
|
|
|
404
|
Other than the above warning, IPython is meant to work as a drop-in
|
|
405
|
Other than the above warning, IPython is meant to work as a drop-in
|
|
405
|
replacement for the standard interactive interpreter. As such, any code
|
|
406
|
replacement for the standard interactive interpreter. As such, any code
|
|
406
|
which is valid python should execute normally under IPython (cases where
|
|
407
|
which is valid python should execute normally under IPython (cases where
|
|
407
|
this is not true should be reported as bugs). It does, however, offer
|
|
408
|
this is not true should be reported as bugs). It does, however, offer
|
|
408
|
many features which are not available at a standard python prompt. What
|
|
409
|
many features which are not available at a standard python prompt. What
|
|
409
|
follows is a list of these.
|
|
410
|
follows is a list of these.
|
|
410
|
|
|
411
|
|
|
411
|
|
|
412
|
|
|
412
|
Caution for Windows users
|
|
413
|
Caution for Windows users
|
|
413
|
-------------------------
|
|
414
|
-------------------------
|
|
414
|
|
|
415
|
|
|
415
|
Windows, unfortunately, uses the '\' character as a path
|
|
416
|
Windows, unfortunately, uses the '\' character as a path
|
|
416
|
separator. This is a terrible choice, because '\' also represents the
|
|
417
|
separator. This is a terrible choice, because '\' also represents the
|
|
417
|
escape character in most modern programming languages, including
|
|
418
|
escape character in most modern programming languages, including
|
|
418
|
Python. For this reason, using '/' character is recommended if you
|
|
419
|
Python. For this reason, using '/' character is recommended if you
|
|
419
|
have problems with ``\``. However, in Windows commands '/' flags
|
|
420
|
have problems with ``\``. However, in Windows commands '/' flags
|
|
420
|
options, so you can not use it for the root directory. This means that
|
|
421
|
options, so you can not use it for the root directory. This means that
|
|
421
|
paths beginning at the root must be typed in a contrived manner like:
|
|
422
|
paths beginning at the root must be typed in a contrived manner like:
|
|
422
|
``%copy \opt/foo/bar.txt \tmp``
|
|
423
|
``%copy \opt/foo/bar.txt \tmp``
|
|
423
|
|
|
424
|
|
|
424
|
.. _magic:
|
|
425
|
.. _magic:
|
|
425
|
|
|
426
|
|
|
426
|
Magic command system
|
|
427
|
Magic command system
|
|
427
|
--------------------
|
|
428
|
--------------------
|
|
428
|
|
|
429
|
|
|
429
|
IPython will treat any line whose first character is a % as a special
|
|
430
|
IPython will treat any line whose first character is a % as a special
|
|
430
|
call to a 'magic' function. These allow you to control the behavior of
|
|
431
|
call to a 'magic' function. These allow you to control the behavior of
|
|
431
|
IPython itself, plus a lot of system-type features. They are all
|
|
432
|
IPython itself, plus a lot of system-type features. They are all
|
|
432
|
prefixed with a % character, but parameters are given without
|
|
433
|
prefixed with a % character, but parameters are given without
|
|
433
|
parentheses or quotes.
|
|
434
|
parentheses or quotes.
|
|
434
|
|
|
435
|
|
|
435
|
Example: typing '%cd mydir' (without the quotes) changes you working
|
|
436
|
Example: typing '%cd mydir' (without the quotes) changes you working
|
|
436
|
directory to 'mydir', if it exists.
|
|
437
|
directory to 'mydir', if it exists.
|
|
437
|
|
|
438
|
|
|
438
|
If you have 'automagic' enabled (in your ipythonrc file, via the command
|
|
439
|
If you have 'automagic' enabled (in your ipythonrc file, via the command
|
|
439
|
line option -automagic or with the %automagic function), you don't need
|
|
440
|
line option -automagic or with the %automagic function), you don't need
|
|
440
|
to type in the % explicitly. IPython will scan its internal list of
|
|
441
|
to type in the % explicitly. IPython will scan its internal list of
|
|
441
|
magic functions and call one if it exists. With automagic on you can
|
|
442
|
magic functions and call one if it exists. With automagic on you can
|
|
442
|
then just type 'cd mydir' to go to directory 'mydir'. The automagic
|
|
443
|
then just type 'cd mydir' to go to directory 'mydir'. The automagic
|
|
443
|
system has the lowest possible precedence in name searches, so defining
|
|
444
|
system has the lowest possible precedence in name searches, so defining
|
|
444
|
an identifier with the same name as an existing magic function will
|
|
445
|
an identifier with the same name as an existing magic function will
|
|
445
|
shadow it for automagic use. You can still access the shadowed magic
|
|
446
|
shadow it for automagic use. You can still access the shadowed magic
|
|
446
|
function by explicitly using the % character at the beginning of the line.
|
|
447
|
function by explicitly using the % character at the beginning of the line.
|
|
447
|
|
|
448
|
|
|
448
|
An example (with automagic on) should clarify all this::
|
|
449
|
An example (with automagic on) should clarify all this::
|
|
449
|
|
|
450
|
|
|
450
|
In [1]: cd ipython # %cd is called by automagic
|
|
451
|
In [1]: cd ipython # %cd is called by automagic
|
|
451
|
|
|
452
|
|
|
452
|
/home/fperez/ipython
|
|
453
|
/home/fperez/ipython
|
|
453
|
|
|
454
|
|
|
454
|
In [2]: cd=1 # now cd is just a variable
|
|
455
|
In [2]: cd=1 # now cd is just a variable
|
|
455
|
|
|
456
|
|
|
456
|
In [3]: cd .. # and doesn't work as a function anymore
|
|
457
|
In [3]: cd .. # and doesn't work as a function anymore
|
|
457
|
|
|
458
|
|
|
458
|
------------------------------
|
|
459
|
------------------------------
|
|
459
|
|
|
460
|
|
|
460
|
File "<console>", line 1
|
|
461
|
File "<console>", line 1
|
|
461
|
|
|
462
|
|
|
462
|
cd ..
|
|
463
|
cd ..
|
|
463
|
|
|
464
|
|
|
464
|
^
|
|
465
|
^
|
|
465
|
|
|
466
|
|
|
466
|
SyntaxError: invalid syntax
|
|
467
|
SyntaxError: invalid syntax
|
|
467
|
|
|
468
|
|
|
468
|
In [4]: %cd .. # but %cd always works
|
|
469
|
In [4]: %cd .. # but %cd always works
|
|
469
|
|
|
470
|
|
|
470
|
/home/fperez
|
|
471
|
/home/fperez
|
|
471
|
|
|
472
|
|
|
472
|
In [5]: del cd # if you remove the cd variable
|
|
473
|
In [5]: del cd # if you remove the cd variable
|
|
473
|
|
|
474
|
|
|
474
|
In [6]: cd ipython # automagic can work again
|
|
475
|
In [6]: cd ipython # automagic can work again
|
|
475
|
|
|
476
|
|
|
476
|
/home/fperez/ipython
|
|
477
|
/home/fperez/ipython
|
|
477
|
|
|
478
|
|
|
478
|
You can define your own magic functions to extend the system. The
|
|
479
|
You can define your own magic functions to extend the system. The
|
|
479
|
following example defines a new magic command, %impall::
|
|
480
|
following example defines a new magic command, %impall::
|
|
480
|
|
|
481
|
|
|
481
|
import IPython.ipapi
|
|
482
|
import IPython.ipapi
|
|
482
|
|
|
483
|
|
|
483
|
ip = IPython.ipapi.get()
|
|
484
|
ip = IPython.ipapi.get()
|
|
484
|
|
|
485
|
|
|
485
|
def doimp(self, arg):
|
|
486
|
def doimp(self, arg):
|
|
486
|
|
|
487
|
|
|
487
|
ip = self.api
|
|
488
|
ip = self.api
|
|
488
|
|
|
489
|
|
|
489
|
ip.ex("import %s; reload(%s); from %s import *" % (
|
|
490
|
ip.ex("import %s; reload(%s); from %s import *" % (
|
|
490
|
|
|
491
|
|
|
491
|
arg,arg,arg)
|
|
492
|
arg,arg,arg)
|
|
492
|
|
|
493
|
|
|
493
|
)
|
|
494
|
)
|
|
494
|
|
|
495
|
|
|
495
|
ip.expose_magic('impall', doimp)
|
|
496
|
ip.expose_magic('impall', doimp)
|
|
496
|
|
|
497
|
|
|
497
|
You can also define your own aliased names for magic functions. In your
|
|
498
|
You can also define your own aliased names for magic functions. In your
|
|
498
|
ipythonrc file, placing a line like:
|
|
499
|
ipythonrc file, placing a line like:
|
|
499
|
|
|
500
|
|
|
500
|
execute __IP.magic_cl = __IP.magic_clear
|
|
501
|
execute __IP.magic_cl = __IP.magic_clear
|
|
501
|
|
|
502
|
|
|
502
|
will define %cl as a new name for %clear.
|
|
503
|
will define %cl as a new name for %clear.
|
|
503
|
|
|
504
|
|
|
504
|
Type %magic for more information, including a list of all available
|
|
505
|
Type %magic for more information, including a list of all available
|
|
505
|
magic functions at any time and their docstrings. You can also type
|
|
506
|
magic functions at any time and their docstrings. You can also type
|
|
506
|
%magic_function_name? (see sec. 6.4 <#sec:dyn-object-info> for
|
|
507
|
%magic_function_name? (see sec. 6.4 <#sec:dyn-object-info> for
|
|
507
|
information on the '?' system) to get information about any particular
|
|
508
|
information on the '?' system) to get information about any particular
|
|
508
|
magic function you are interested in.
|
|
509
|
magic function you are interested in.
|
|
509
|
|
|
510
|
|
|
510
|
|
|
511
|
|
|
511
|
Magic commands
|
|
512
|
Magic commands
|
|
512
|
--------------
|
|
513
|
--------------
|
|
513
|
|
|
514
|
|
|
514
|
The rest of this section is automatically generated for each release
|
|
515
|
The rest of this section is automatically generated for each release
|
|
515
|
from the docstrings in the IPython code. Therefore the formatting is
|
|
516
|
from the docstrings in the IPython code. Therefore the formatting is
|
|
516
|
somewhat minimal, but this method has the advantage of having
|
|
517
|
somewhat minimal, but this method has the advantage of having
|
|
517
|
information always in sync with the code.
|
|
518
|
information always in sync with the code.
|
|
518
|
|
|
519
|
|
|
519
|
A list of all the magic commands available in IPython's default
|
|
520
|
A list of all the magic commands available in IPython's default
|
|
520
|
installation follows. This is similar to what you'll see by simply
|
|
521
|
installation follows. This is similar to what you'll see by simply
|
|
521
|
typing %magic at the prompt, but that will also give you information
|
|
522
|
typing %magic at the prompt, but that will also give you information
|
|
522
|
about magic commands you may have added as part of your personal
|
|
523
|
about magic commands you may have added as part of your personal
|
|
523
|
customizations.
|
|
524
|
customizations.
|
|
524
|
|
|
525
|
|
|
525
|
.. magic_start
|
|
526
|
.. magic_start
|
|
526
|
|
|
527
|
|
|
527
|
**%Exit**::
|
|
528
|
**%Exit**::
|
|
528
|
|
|
529
|
|
|
529
|
Exit IPython without confirmation.
|
|
530
|
Exit IPython without confirmation.
|
|
530
|
|
|
531
|
|
|
531
|
**%Pprint**::
|
|
532
|
**%Pprint**::
|
|
532
|
|
|
533
|
|
|
533
|
Toggle pretty printing on/off.
|
|
534
|
Toggle pretty printing on/off.
|
|
534
|
|
|
535
|
|
|
535
|
**%alias**::
|
|
536
|
**%alias**::
|
|
536
|
|
|
537
|
|
|
537
|
Define an alias for a system command.
|
|
538
|
Define an alias for a system command.
|
|
538
|
|
|
539
|
|
|
539
|
'%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
|
|
540
|
'%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
|
|
540
|
|
|
541
|
|
|
541
|
Then, typing 'alias_name params' will execute the system command 'cmd
|
|
542
|
Then, typing 'alias_name params' will execute the system command 'cmd
|
|
542
|
params' (from your underlying operating system).
|
|
543
|
params' (from your underlying operating system).
|
|
543
|
|
|
544
|
|
|
544
|
Aliases have lower precedence than magic functions and Python normal
|
|
545
|
Aliases have lower precedence than magic functions and Python normal
|
|
545
|
variables, so if 'foo' is both a Python variable and an alias, the
|
|
546
|
variables, so if 'foo' is both a Python variable and an alias, the
|
|
546
|
alias can not be executed until 'del foo' removes the Python variable.
|
|
547
|
alias can not be executed until 'del foo' removes the Python variable.
|
|
547
|
|
|
548
|
|
|
548
|
You can use the %l specifier in an alias definition to represent the
|
|
549
|
You can use the %l specifier in an alias definition to represent the
|
|
549
|
whole line when the alias is called. For example:
|
|
550
|
whole line when the alias is called. For example:
|
|
550
|
|
|
551
|
|
|
551
|
In [2]: alias all echo "Input in brackets: <%l>"\
|
|
552
|
In [2]: alias all echo "Input in brackets: <%l>"\
|
|
552
|
In [3]: all hello world\
|
|
553
|
In [3]: all hello world\
|
|
553
|
Input in brackets: <hello world>
|
|
554
|
Input in brackets: <hello world>
|
|
554
|
|
|
555
|
|
|
555
|
You can also define aliases with parameters using %s specifiers (one
|
|
556
|
You can also define aliases with parameters using %s specifiers (one
|
|
556
|
per parameter):
|
|
557
|
per parameter):
|
|
557
|
|
|
558
|
|
|
558
|
In [1]: alias parts echo first %s second %s\
|
|
559
|
In [1]: alias parts echo first %s second %s\
|
|
559
|
In [2]: %parts A B\
|
|
560
|
In [2]: %parts A B\
|
|
560
|
first A second B\
|
|
561
|
first A second B\
|
|
561
|
In [3]: %parts A\
|
|
562
|
In [3]: %parts A\
|
|
562
|
Incorrect number of arguments: 2 expected.\
|
|
563
|
Incorrect number of arguments: 2 expected.\
|
|
563
|
parts is an alias to: 'echo first %s second %s'
|
|
564
|
parts is an alias to: 'echo first %s second %s'
|
|
564
|
|
|
565
|
|
|
565
|
Note that %l and %s are mutually exclusive. You can only use one or
|
|
566
|
Note that %l and %s are mutually exclusive. You can only use one or
|
|
566
|
the other in your aliases.
|
|
567
|
the other in your aliases.
|
|
567
|
|
|
568
|
|
|
568
|
Aliases expand Python variables just like system calls using ! or !!
|
|
569
|
Aliases expand Python variables just like system calls using ! or !!
|
|
569
|
do: all expressions prefixed with '$' get expanded. For details of
|
|
570
|
do: all expressions prefixed with '$' get expanded. For details of
|
|
570
|
the semantic rules, see PEP-215:
|
|
571
|
the semantic rules, see PEP-215:
|
|
571
|
http://www.python.org/peps/pep-0215.html. This is the library used by
|
|
572
|
http://www.python.org/peps/pep-0215.html. This is the library used by
|
|
572
|
IPython for variable expansion. If you want to access a true shell
|
|
573
|
IPython for variable expansion. If you want to access a true shell
|
|
573
|
variable, an extra $ is necessary to prevent its expansion by IPython:
|
|
574
|
variable, an extra $ is necessary to prevent its expansion by IPython:
|
|
574
|
|
|
575
|
|
|
575
|
In [6]: alias show echo\
|
|
576
|
In [6]: alias show echo\
|
|
576
|
In [7]: PATH='A Python string'\
|
|
577
|
In [7]: PATH='A Python string'\
|
|
577
|
In [8]: show $PATH\
|
|
578
|
In [8]: show $PATH\
|
|
578
|
A Python string\
|
|
579
|
A Python string\
|
|
579
|
In [9]: show $$PATH\
|
|
580
|
In [9]: show $$PATH\
|
|
580
|
/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
|
|
581
|
/usr/local/lf9560/bin:/usr/local/intel/compiler70/ia32/bin:...
|
|
581
|
|
|
582
|
|
|
582
|
You can use the alias facility to acess all of $PATH. See the %rehash
|
|
583
|
You can use the alias facility to acess all of $PATH. See the %rehash
|
|
583
|
and %rehashx functions, which automatically create aliases for the
|
|
584
|
and %rehashx functions, which automatically create aliases for the
|
|
584
|
contents of your $PATH.
|
|
585
|
contents of your $PATH.
|
|
585
|
|
|
586
|
|
|
586
|
If called with no parameters, %alias prints the current alias table.
|
|
587
|
If called with no parameters, %alias prints the current alias table.
|
|
587
|
|
|
588
|
|
|
588
|
**%autocall**::
|
|
589
|
**%autocall**::
|
|
589
|
|
|
590
|
|
|
590
|
Make functions callable without having to type parentheses.
|
|
591
|
Make functions callable without having to type parentheses.
|
|
591
|
|
|
592
|
|
|
592
|
Usage:
|
|
593
|
Usage:
|
|
593
|
|
|
594
|
|
|
594
|
%autocall [mode]
|
|
595
|
%autocall [mode]
|
|
595
|
|
|
596
|
|
|
596
|
The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
|
|
597
|
The mode can be one of: 0->Off, 1->Smart, 2->Full. If not given, the
|
|
597
|
value is toggled on and off (remembering the previous state).
|
|
598
|
value is toggled on and off (remembering the previous state).
|
|
598
|
|
|
599
|
|
|
599
|
In more detail, these values mean:
|
|
600
|
In more detail, these values mean:
|
|
600
|
|
|
601
|
|
|
601
|
0 -> fully disabled
|
|
602
|
0 -> fully disabled
|
|
602
|
|
|
603
|
|
|
603
|
1 -> active, but do not apply if there are no arguments on the line.
|
|
604
|
1 -> active, but do not apply if there are no arguments on the line.
|
|
604
|
|
|
605
|
|
|
605
|
In this mode, you get:
|
|
606
|
In this mode, you get:
|
|
606
|
|
|
607
|
|
|
607
|
In [1]: callable
|
|
608
|
In [1]: callable
|
|
608
|
Out[1]: <built-in function callable>
|
|
609
|
Out[1]: <built-in function callable>
|
|
609
|
|
|
610
|
|
|
610
|
In [2]: callable 'hello'
|
|
611
|
In [2]: callable 'hello'
|
|
611
|
------> callable('hello')
|
|
612
|
------> callable('hello')
|
|
612
|
Out[2]: False
|
|
613
|
Out[2]: False
|
|
613
|
|
|
614
|
|
|
614
|
2 -> Active always. Even if no arguments are present, the callable
|
|
615
|
2 -> Active always. Even if no arguments are present, the callable
|
|
615
|
object is called:
|
|
616
|
object is called:
|
|
616
|
|
|
617
|
|
|
617
|
In [4]: callable
|
|
618
|
In [4]: callable
|
|
618
|
------> callable()
|
|
619
|
------> callable()
|
|
619
|
|
|
620
|
|
|
620
|
Note that even with autocall off, you can still use '/' at the start of
|
|
621
|
Note that even with autocall off, you can still use '/' at the start of
|
|
621
|
a line to treat the first argument on the command line as a function
|
|
622
|
a line to treat the first argument on the command line as a function
|
|
622
|
and add parentheses to it:
|
|
623
|
and add parentheses to it:
|
|
623
|
|
|
624
|
|
|
624
|
In [8]: /str 43
|
|
625
|
In [8]: /str 43
|
|
625
|
------> str(43)
|
|
626
|
------> str(43)
|
|
626
|
Out[8]: '43'
|
|
627
|
Out[8]: '43'
|
|
627
|
|
|
628
|
|
|
628
|
**%autoindent**::
|
|
629
|
**%autoindent**::
|
|
629
|
|
|
630
|
|
|
630
|
Toggle autoindent on/off (if available).
|
|
631
|
Toggle autoindent on/off (if available).
|
|
631
|
|
|
632
|
|
|
632
|
**%automagic**::
|
|
633
|
**%automagic**::
|
|
633
|
|
|
634
|
|
|
634
|
Make magic functions callable without having to type the initial %.
|
|
635
|
Make magic functions callable without having to type the initial %.
|
|
635
|
|
|
636
|
|
|
636
|
Without argumentsl toggles on/off (when off, you must call it as
|
|
637
|
Without argumentsl toggles on/off (when off, you must call it as
|
|
637
|
%automagic, of course). With arguments it sets the value, and you can
|
|
638
|
%automagic, of course). With arguments it sets the value, and you can
|
|
638
|
use any of (case insensitive):
|
|
639
|
use any of (case insensitive):
|
|
639
|
|
|
640
|
|
|
640
|
- on,1,True: to activate
|
|
641
|
- on,1,True: to activate
|
|
641
|
|
|
642
|
|
|
642
|
- off,0,False: to deactivate.
|
|
643
|
- off,0,False: to deactivate.
|
|
643
|
|
|
644
|
|
|
644
|
Note that magic functions have lowest priority, so if there's a
|
|
645
|
Note that magic functions have lowest priority, so if there's a
|
|
645
|
variable whose name collides with that of a magic fn, automagic won't
|
|
646
|
variable whose name collides with that of a magic fn, automagic won't
|
|
646
|
work for that function (you get the variable instead). However, if you
|
|
647
|
work for that function (you get the variable instead). However, if you
|
|
647
|
delete the variable (del var), the previously shadowed magic function
|
|
648
|
delete the variable (del var), the previously shadowed magic function
|
|
648
|
becomes visible to automagic again.
|
|
649
|
becomes visible to automagic again.
|
|
649
|
|
|
650
|
|
|
650
|
**%bg**::
|
|
651
|
**%bg**::
|
|
651
|
|
|
652
|
|
|
652
|
Run a job in the background, in a separate thread.
|
|
653
|
Run a job in the background, in a separate thread.
|
|
653
|
|
|
654
|
|
|
654
|
For example,
|
|
655
|
For example,
|
|
655
|
|
|
656
|
|
|
656
|
%bg myfunc(x,y,z=1)
|
|
657
|
%bg myfunc(x,y,z=1)
|
|
657
|
|
|
658
|
|
|
658
|
will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
|
|
659
|
will execute 'myfunc(x,y,z=1)' in a background thread. As soon as the
|
|
659
|
execution starts, a message will be printed indicating the job
|
|
660
|
execution starts, a message will be printed indicating the job
|
|
660
|
number. If your job number is 5, you can use
|
|
661
|
number. If your job number is 5, you can use
|
|
661
|
|
|
662
|
|
|
662
|
myvar = jobs.result(5) or myvar = jobs[5].result
|
|
663
|
myvar = jobs.result(5) or myvar = jobs[5].result
|
|
663
|
|
|
664
|
|
|
664
|
to assign this result to variable 'myvar'.
|
|
665
|
to assign this result to variable 'myvar'.
|
|
665
|
|
|
666
|
|
|
666
|
IPython has a job manager, accessible via the 'jobs' object. You can
|
|
667
|
IPython has a job manager, accessible via the 'jobs' object. You can
|
|
667
|
type jobs? to get more information about it, and use jobs.<TAB> to see
|
|
668
|
type jobs? to get more information about it, and use jobs.<TAB> to see
|
|
668
|
its attributes. All attributes not starting with an underscore are
|
|
669
|
its attributes. All attributes not starting with an underscore are
|
|
669
|
meant for public use.
|
|
670
|
meant for public use.
|
|
670
|
|
|
671
|
|
|
671
|
In particular, look at the jobs.new() method, which is used to create
|
|
672
|
In particular, look at the jobs.new() method, which is used to create
|
|
672
|
new jobs. This magic %bg function is just a convenience wrapper
|
|
673
|
new jobs. This magic %bg function is just a convenience wrapper
|
|
673
|
around jobs.new(), for expression-based jobs. If you want to create a
|
|
674
|
around jobs.new(), for expression-based jobs. If you want to create a
|
|
674
|
new job with an explicit function object and arguments, you must call
|
|
675
|
new job with an explicit function object and arguments, you must call
|
|
675
|
jobs.new() directly.
|
|
676
|
jobs.new() directly.
|
|
676
|
|
|
677
|
|
|
677
|
The jobs.new docstring also describes in detail several important
|
|
678
|
The jobs.new docstring also describes in detail several important
|
|
678
|
caveats associated with a thread-based model for background job
|
|
679
|
caveats associated with a thread-based model for background job
|
|
679
|
execution. Type jobs.new? for details.
|
|
680
|
execution. Type jobs.new? for details.
|
|
680
|
|
|
681
|
|
|
681
|
You can check the status of all jobs with jobs.status().
|
|
682
|
You can check the status of all jobs with jobs.status().
|
|
682
|
|
|
683
|
|
|
683
|
The jobs variable is set by IPython into the Python builtin namespace.
|
|
684
|
The jobs variable is set by IPython into the Python builtin namespace.
|
|
684
|
If you ever declare a variable named 'jobs', you will shadow this
|
|
685
|
If you ever declare a variable named 'jobs', you will shadow this
|
|
685
|
name. You can either delete your global jobs variable to regain
|
|
686
|
name. You can either delete your global jobs variable to regain
|
|
686
|
access to the job manager, or make a new name and assign it manually
|
|
687
|
access to the job manager, or make a new name and assign it manually
|
|
687
|
to the manager (stored in IPython's namespace). For example, to
|
|
688
|
to the manager (stored in IPython's namespace). For example, to
|
|
688
|
assign the job manager to the Jobs name, use:
|
|
689
|
assign the job manager to the Jobs name, use:
|
|
689
|
|
|
690
|
|
|
690
|
Jobs = __builtins__.jobs
|
|
691
|
Jobs = __builtins__.jobs
|
|
691
|
|
|
692
|
|
|
692
|
**%bookmark**::
|
|
693
|
**%bookmark**::
|
|
693
|
|
|
694
|
|
|
694
|
Manage IPython's bookmark system.
|
|
695
|
Manage IPython's bookmark system.
|
|
695
|
|
|
696
|
|
|
696
|
%bookmark <name> - set bookmark to current dir
|
|
697
|
%bookmark <name> - set bookmark to current dir
|
|
697
|
%bookmark <name> <dir> - set bookmark to <dir>
|
|
698
|
%bookmark <name> <dir> - set bookmark to <dir>
|
|
698
|
%bookmark -l - list all bookmarks
|
|
699
|
%bookmark -l - list all bookmarks
|
|
699
|
%bookmark -d <name> - remove bookmark
|
|
700
|
%bookmark -d <name> - remove bookmark
|
|
700
|
%bookmark -r - remove all bookmarks
|
|
701
|
%bookmark -r - remove all bookmarks
|
|
701
|
|
|
702
|
|
|
702
|
You can later on access a bookmarked folder with:
|
|
703
|
You can later on access a bookmarked folder with:
|
|
703
|
%cd -b <name>
|
|
704
|
%cd -b <name>
|
|
704
|
or simply '%cd <name>' if there is no directory called <name> AND
|
|
705
|
or simply '%cd <name>' if there is no directory called <name> AND
|
|
705
|
there is such a bookmark defined.
|
|
706
|
there is such a bookmark defined.
|
|
706
|
|
|
707
|
|
|
707
|
Your bookmarks persist through IPython sessions, but they are
|
|
708
|
Your bookmarks persist through IPython sessions, but they are
|
|
708
|
associated with each profile.
|
|
709
|
associated with each profile.
|
|
709
|
|
|
710
|
|
|
710
|
**%cd**::
|
|
711
|
**%cd**::
|
|
711
|
|
|
712
|
|
|
712
|
Change the current working directory.
|
|
713
|
Change the current working directory.
|
|
713
|
|
|
714
|
|
|
714
|
This command automatically maintains an internal list of directories
|
|
715
|
This command automatically maintains an internal list of directories
|
|
715
|
you visit during your IPython session, in the variable _dh. The
|
|
716
|
you visit during your IPython session, in the variable _dh. The
|
|
716
|
command %dhist shows this history nicely formatted. You can also
|
|
717
|
command %dhist shows this history nicely formatted. You can also
|
|
717
|
do 'cd -<tab>' to see directory history conveniently.
|
|
718
|
do 'cd -<tab>' to see directory history conveniently.
|
|
718
|
|
|
719
|
|
|
719
|
Usage:
|
|
720
|
Usage:
|
|
720
|
|
|
721
|
|
|
721
|
cd 'dir': changes to directory 'dir'.
|
|
722
|
cd 'dir': changes to directory 'dir'.
|
|
722
|
|
|
723
|
|
|
723
|
cd -: changes to the last visited directory.
|
|
724
|
cd -: changes to the last visited directory.
|
|
724
|
|
|
725
|
|
|
725
|
cd -<n>: changes to the n-th directory in the directory history.
|
|
726
|
cd -<n>: changes to the n-th directory in the directory history.
|
|
726
|
|
|
727
|
|
|
727
|
cd -b <bookmark_name>: jump to a bookmark set by %bookmark
|
|
728
|
cd -b <bookmark_name>: jump to a bookmark set by %bookmark
|
|
728
|
(note: cd <bookmark_name> is enough if there is no
|
|
729
|
(note: cd <bookmark_name> is enough if there is no
|
|
729
|
directory <bookmark_name>, but a bookmark with the name exists.)
|
|
730
|
directory <bookmark_name>, but a bookmark with the name exists.)
|
|
730
|
'cd -b <tab>' allows you to tab-complete bookmark names.
|
|
731
|
'cd -b <tab>' allows you to tab-complete bookmark names.
|
|
731
|
|
|
732
|
|
|
732
|
Options:
|
|
733
|
Options:
|
|
733
|
|
|
734
|
|
|
734
|
-q: quiet. Do not print the working directory after the cd command is
|
|
735
|
-q: quiet. Do not print the working directory after the cd command is
|
|
735
|
executed. By default IPython's cd command does print this directory,
|
|
736
|
executed. By default IPython's cd command does print this directory,
|
|
736
|
since the default prompts do not display path information.
|
|
737
|
since the default prompts do not display path information.
|
|
737
|
|
|
738
|
|
|
738
|
Note that !cd doesn't work for this purpose because the shell where
|
|
739
|
Note that !cd doesn't work for this purpose because the shell where
|
|
739
|
!command runs is immediately discarded after executing 'command'.
|
|
740
|
!command runs is immediately discarded after executing 'command'.
|
|
740
|
|
|
741
|
|
|
741
|
**%clear**::
|
|
742
|
**%clear**::
|
|
742
|
|
|
743
|
|
|
743
|
Clear various data (e.g. stored history data)
|
|
744
|
Clear various data (e.g. stored history data)
|
|
744
|
|
|
745
|
|
|
745
|
%clear out - clear output history
|
|
746
|
%clear out - clear output history
|
|
746
|
%clear in - clear input history
|
|
747
|
%clear in - clear input history
|
|
747
|
%clear shadow_compress - Compresses shadow history (to speed up ipython)
|
|
748
|
%clear shadow_compress - Compresses shadow history (to speed up ipython)
|
|
748
|
%clear shadow_nuke - permanently erase all entries in shadow history
|
|
749
|
%clear shadow_nuke - permanently erase all entries in shadow history
|
|
749
|
%clear dhist - clear dir history
|
|
750
|
%clear dhist - clear dir history
|
|
750
|
|
|
751
|
|
|
751
|
**%color_info**::
|
|
752
|
**%color_info**::
|
|
752
|
|
|
753
|
|
|
753
|
Toggle color_info.
|
|
754
|
Toggle color_info.
|
|
754
|
|
|
755
|
|
|
755
|
The color_info configuration parameter controls whether colors are
|
|
756
|
The color_info configuration parameter controls whether colors are
|
|
756
|
used for displaying object details (by things like %psource, %pfile or
|
|
757
|
used for displaying object details (by things like %psource, %pfile or
|
|
757
|
the '?' system). This function toggles this value with each call.
|
|
758
|
the '?' system). This function toggles this value with each call.
|
|
758
|
|
|
759
|
|
|
759
|
Note that unless you have a fairly recent pager (less works better
|
|
760
|
Note that unless you have a fairly recent pager (less works better
|
|
760
|
than more) in your system, using colored object information displays
|
|
761
|
than more) in your system, using colored object information displays
|
|
761
|
will not work properly. Test it and see.
|
|
762
|
will not work properly. Test it and see.
|
|
762
|
|
|
763
|
|
|
763
|
**%colors**::
|
|
764
|
**%colors**::
|
|
764
|
|
|
765
|
|
|
765
|
Switch color scheme for prompts, info system and exception handlers.
|
|
766
|
Switch color scheme for prompts, info system and exception handlers.
|
|
766
|
|
|
767
|
|
|
767
|
Currently implemented schemes: NoColor, Linux, LightBG.
|
|
768
|
Currently implemented schemes: NoColor, Linux, LightBG.
|
|
768
|
|
|
769
|
|
|
769
|
Color scheme names are not case-sensitive.
|
|
770
|
Color scheme names are not case-sensitive.
|
|
770
|
|
|
771
|
|
|
771
|
**%cpaste**::
|
|
772
|
**%cpaste**::
|
|
772
|
|
|
773
|
|
|
773
|
Allows you to paste & execute a pre-formatted code block from clipboard
|
|
774
|
Allows you to paste & execute a pre-formatted code block from clipboard
|
|
774
|
|
|
775
|
|
|
775
|
You must terminate the block with '--' (two minus-signs) alone on the
|
|
776
|
You must terminate the block with '--' (two minus-signs) alone on the
|
|
776
|
line. You can also provide your own sentinel with '%paste -s %%' ('%%'
|
|
777
|
line. You can also provide your own sentinel with '%paste -s %%' ('%%'
|
|
777
|
is the new sentinel for this operation)
|
|
778
|
is the new sentinel for this operation)
|
|
778
|
|
|
779
|
|
|
779
|
The block is dedented prior to execution to enable execution of method
|
|
780
|
The block is dedented prior to execution to enable execution of method
|
|
780
|
definitions. '>' and '+' characters at the beginning of a line are
|
|
781
|
definitions. '>' and '+' characters at the beginning of a line are
|
|
781
|
ignored, to allow pasting directly from e-mails or diff files. The
|
|
782
|
ignored, to allow pasting directly from e-mails or diff files. The
|
|
782
|
executed block is also assigned to variable named 'pasted_block' for
|
|
783
|
executed block is also assigned to variable named 'pasted_block' for
|
|
783
|
later editing with '%edit pasted_block'.
|
|
784
|
later editing with '%edit pasted_block'.
|
|
784
|
|
|
785
|
|
|
785
|
You can also pass a variable name as an argument, e.g. '%cpaste foo'.
|
|
786
|
You can also pass a variable name as an argument, e.g. '%cpaste foo'.
|
|
786
|
This assigns the pasted block to variable 'foo' as string, without
|
|
787
|
This assigns the pasted block to variable 'foo' as string, without
|
|
787
|
dedenting or executing it.
|
|
788
|
dedenting or executing it.
|
|
788
|
|
|
789
|
|
|
789
|
Do not be alarmed by garbled output on Windows (it's a readline bug).
|
|
790
|
Do not be alarmed by garbled output on Windows (it's a readline bug).
|
|
790
|
Just press enter and type -- (and press enter again) and the block
|
|
791
|
Just press enter and type -- (and press enter again) and the block
|
|
791
|
will be what was just pasted.
|
|
792
|
will be what was just pasted.
|
|
792
|
|
|
793
|
|
|
793
|
IPython statements (magics, shell escapes) are not supported (yet).
|
|
794
|
IPython statements (magics, shell escapes) are not supported (yet).
|
|
794
|
|
|
795
|
|
|
795
|
**%debug**::
|
|
796
|
**%debug**::
|
|
796
|
|
|
797
|
|
|
797
|
Activate the interactive debugger in post-mortem mode.
|
|
798
|
Activate the interactive debugger in post-mortem mode.
|
|
798
|
|
|
799
|
|
|
799
|
If an exception has just occurred, this lets you inspect its stack
|
|
800
|
If an exception has just occurred, this lets you inspect its stack
|
|
800
|
frames interactively. Note that this will always work only on the last
|
|
801
|
frames interactively. Note that this will always work only on the last
|
|
801
|
traceback that occurred, so you must call this quickly after an
|
|
802
|
traceback that occurred, so you must call this quickly after an
|
|
802
|
exception that you wish to inspect has fired, because if another one
|
|
803
|
exception that you wish to inspect has fired, because if another one
|
|
803
|
occurs, it clobbers the previous one.
|
|
804
|
occurs, it clobbers the previous one.
|
|
804
|
|
|
805
|
|
|
805
|
If you want IPython to automatically do this on every exception, see
|
|
806
|
If you want IPython to automatically do this on every exception, see
|
|
806
|
the %pdb magic for more details.
|
|
807
|
the %pdb magic for more details.
|
|
807
|
|
|
808
|
|
|
808
|
**%dhist**::
|
|
809
|
**%dhist**::
|
|
809
|
|
|
810
|
|
|
810
|
Print your history of visited directories.
|
|
811
|
Print your history of visited directories.
|
|
811
|
|
|
812
|
|
|
812
|
%dhist -> print full history\
|
|
813
|
%dhist -> print full history\
|
|
813
|
%dhist n -> print last n entries only\
|
|
814
|
%dhist n -> print last n entries only\
|
|
814
|
%dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\
|
|
815
|
%dhist n1 n2 -> print entries between n1 and n2 (n1 not included)\
|
|
815
|
|
|
816
|
|
|
816
|
This history is automatically maintained by the %cd command, and
|
|
817
|
This history is automatically maintained by the %cd command, and
|
|
817
|
always available as the global list variable _dh. You can use %cd -<n>
|
|
818
|
always available as the global list variable _dh. You can use %cd -<n>
|
|
818
|
to go to directory number <n>.
|
|
819
|
to go to directory number <n>.
|
|
819
|
|
|
820
|
|
|
820
|
Note that most of time, you should view directory history by entering
|
|
821
|
Note that most of time, you should view directory history by entering
|
|
821
|
cd -<TAB>.
|
|
822
|
cd -<TAB>.
|
|
822
|
|
|
823
|
|
|
823
|
**%dirs**::
|
|
824
|
**%dirs**::
|
|
824
|
|
|
825
|
|
|
825
|
Return the current directory stack.
|
|
826
|
Return the current directory stack.
|
|
826
|
|
|
827
|
|
|
827
|
**%doctest_mode**::
|
|
828
|
**%doctest_mode**::
|
|
828
|
|
|
829
|
|
|
829
|
Toggle doctest mode on and off.
|
|
830
|
Toggle doctest mode on and off.
|
|
830
|
|
|
831
|
|
|
831
|
This mode allows you to toggle the prompt behavior between normal
|
|
832
|
This mode allows you to toggle the prompt behavior between normal
|
|
832
|
IPython prompts and ones that are as similar to the default IPython
|
|
833
|
IPython prompts and ones that are as similar to the default IPython
|
|
833
|
interpreter as possible.
|
|
834
|
interpreter as possible.
|
|
834
|
|
|
835
|
|
|
835
|
It also supports the pasting of code snippets that have leading '>>>'
|
|
836
|
It also supports the pasting of code snippets that have leading '>>>'
|
|
836
|
and '...' prompts in them. This means that you can paste doctests from
|
|
837
|
and '...' prompts in them. This means that you can paste doctests from
|
|
837
|
files or docstrings (even if they have leading whitespace), and the
|
|
838
|
files or docstrings (even if they have leading whitespace), and the
|
|
838
|
code will execute correctly. You can then use '%history -tn' to see
|
|
839
|
code will execute correctly. You can then use '%history -tn' to see
|
|
839
|
the translated history without line numbers; this will give you the
|
|
840
|
the translated history without line numbers; this will give you the
|
|
840
|
input after removal of all the leading prompts and whitespace, which
|
|
841
|
input after removal of all the leading prompts and whitespace, which
|
|
841
|
can be pasted back into an editor.
|
|
842
|
can be pasted back into an editor.
|
|
842
|
|
|
843
|
|
|
843
|
With these features, you can switch into this mode easily whenever you
|
|
844
|
With these features, you can switch into this mode easily whenever you
|
|
844
|
need to do testing and changes to doctests, without having to leave
|
|
845
|
need to do testing and changes to doctests, without having to leave
|
|
845
|
your existing IPython session.
|
|
846
|
your existing IPython session.
|
|
846
|
|
|
847
|
|
|
847
|
**%ed**::
|
|
848
|
**%ed**::
|
|
848
|
|
|
849
|
|
|
849
|
Alias to %edit.
|
|
850
|
Alias to %edit.
|
|
850
|
|
|
851
|
|
|
851
|
**%edit**::
|
|
852
|
**%edit**::
|
|
852
|
|
|
853
|
|
|
853
|
Bring up an editor and execute the resulting code.
|
|
854
|
Bring up an editor and execute the resulting code.
|
|
854
|
|
|
855
|
|
|
855
|
Usage:
|
|
856
|
Usage:
|
|
856
|
%edit [options] [args]
|
|
857
|
%edit [options] [args]
|
|
857
|
|
|
858
|
|
|
858
|
%edit runs IPython's editor hook. The default version of this hook is
|
|
859
|
%edit runs IPython's editor hook. The default version of this hook is
|
|
859
|
set to call the __IPYTHON__.rc.editor command. This is read from your
|
|
860
|
set to call the __IPYTHON__.rc.editor command. This is read from your
|
|
860
|
environment variable $EDITOR. If this isn't found, it will default to
|
|
861
|
environment variable $EDITOR. If this isn't found, it will default to
|
|
861
|
vi under Linux/Unix and to notepad under Windows. See the end of this
|
|
862
|
vi under Linux/Unix and to notepad under Windows. See the end of this
|
|
862
|
docstring for how to change the editor hook.
|
|
863
|
docstring for how to change the editor hook.
|
|
863
|
|
|
864
|
|
|
864
|
You can also set the value of this editor via the command line option
|
|
865
|
You can also set the value of this editor via the command line option
|
|
865
|
'-editor' or in your ipythonrc file. This is useful if you wish to use
|
|
866
|
'-editor' or in your ipythonrc file. This is useful if you wish to use
|
|
866
|
specifically for IPython an editor different from your typical default
|
|
867
|
specifically for IPython an editor different from your typical default
|
|
867
|
(and for Windows users who typically don't set environment variables).
|
|
868
|
(and for Windows users who typically don't set environment variables).
|
|
868
|
|
|
869
|
|
|
869
|
This command allows you to conveniently edit multi-line code right in
|
|
870
|
This command allows you to conveniently edit multi-line code right in
|
|
870
|
your IPython session.
|
|
871
|
your IPython session.
|
|
871
|
|
|
872
|
|
|
872
|
If called without arguments, %edit opens up an empty editor with a
|
|
873
|
If called without arguments, %edit opens up an empty editor with a
|
|
873
|
temporary file and will execute the contents of this file when you
|
|
874
|
temporary file and will execute the contents of this file when you
|
|
874
|
close it (don't forget to save it!).
|
|
875
|
close it (don't forget to save it!).
|
|
875
|
|
|
876
|
|
|
876
|
|
|
877
|
|
|
877
|
Options:
|
|
878
|
Options:
|
|
878
|
|
|
879
|
|
|
879
|
-n <number>: open the editor at a specified line number. By default,
|
|
880
|
-n <number>: open the editor at a specified line number. By default,
|
|
880
|
the IPython editor hook uses the unix syntax 'editor +N filename', but
|
|
881
|
the IPython editor hook uses the unix syntax 'editor +N filename', but
|
|
881
|
you can configure this by providing your own modified hook if your
|
|
882
|
you can configure this by providing your own modified hook if your
|
|
882
|
favorite editor supports line-number specifications with a different
|
|
883
|
favorite editor supports line-number specifications with a different
|
|
883
|
syntax.
|
|
884
|
syntax.
|
|
884
|
|
|
885
|
|
|
885
|
-p: this will call the editor with the same data as the previous time
|
|
886
|
-p: this will call the editor with the same data as the previous time
|
|
886
|
it was used, regardless of how long ago (in your current session) it
|
|
887
|
it was used, regardless of how long ago (in your current session) it
|
|
887
|
was.
|
|
888
|
was.
|
|
888
|
|
|
889
|
|
|
889
|
-r: use 'raw' input. This option only applies to input taken from the
|
|
890
|
-r: use 'raw' input. This option only applies to input taken from the
|
|
890
|
user's history. By default, the 'processed' history is used, so that
|
|
891
|
user's history. By default, the 'processed' history is used, so that
|
|
891
|
magics are loaded in their transformed version to valid Python. If
|
|
892
|
magics are loaded in their transformed version to valid Python. If
|
|
892
|
this option is given, the raw input as typed as the command line is
|
|
893
|
this option is given, the raw input as typed as the command line is
|
|
893
|
used instead. When you exit the editor, it will be executed by
|
|
894
|
used instead. When you exit the editor, it will be executed by
|
|
894
|
IPython's own processor.
|
|
895
|
IPython's own processor.
|
|
895
|
|
|
896
|
|
|
896
|
-x: do not execute the edited code immediately upon exit. This is
|
|
897
|
-x: do not execute the edited code immediately upon exit. This is
|
|
897
|
mainly useful if you are editing programs which need to be called with
|
|
898
|
mainly useful if you are editing programs which need to be called with
|
|
898
|
command line arguments, which you can then do using %run.
|
|
899
|
command line arguments, which you can then do using %run.
|
|
899
|
|
|
900
|
|
|
900
|
|
|
901
|
|
|
901
|
Arguments:
|
|
902
|
Arguments:
|
|
902
|
|
|
903
|
|
|
903
|
If arguments are given, the following possibilites exist:
|
|
904
|
If arguments are given, the following possibilites exist:
|
|
904
|
|
|
905
|
|
|
905
|
- The arguments are numbers or pairs of colon-separated numbers (like
|
|
906
|
- The arguments are numbers or pairs of colon-separated numbers (like
|
|
906
|
1 4:8 9). These are interpreted as lines of previous input to be
|
|
907
|
1 4:8 9). These are interpreted as lines of previous input to be
|
|
907
|
loaded into the editor. The syntax is the same of the %macro command.
|
|
908
|
loaded into the editor. The syntax is the same of the %macro command.
|
|
908
|
|
|
909
|
|
|
909
|
- If the argument doesn't start with a number, it is evaluated as a
|
|
910
|
- If the argument doesn't start with a number, it is evaluated as a
|
|
910
|
variable and its contents loaded into the editor. You can thus edit
|
|
911
|
variable and its contents loaded into the editor. You can thus edit
|
|
911
|
any string which contains python code (including the result of
|
|
912
|
any string which contains python code (including the result of
|
|
912
|
previous edits).
|
|
913
|
previous edits).
|
|
913
|
|
|
914
|
|
|
914
|
- If the argument is the name of an object (other than a string),
|
|
915
|
- If the argument is the name of an object (other than a string),
|
|
915
|
IPython will try to locate the file where it was defined and open the
|
|
916
|
IPython will try to locate the file where it was defined and open the
|
|
916
|
editor at the point where it is defined. You can use `%edit function`
|
|
917
|
editor at the point where it is defined. You can use `%edit function`
|
|
917
|
to load an editor exactly at the point where 'function' is defined,
|
|
918
|
to load an editor exactly at the point where 'function' is defined,
|
|
918
|
edit it and have the file be executed automatically.
|
|
919
|
edit it and have the file be executed automatically.
|
|
919
|
|
|
920
|
|
|
920
|
If the object is a macro (see %macro for details), this opens up your
|
|
921
|
If the object is a macro (see %macro for details), this opens up your
|
|
921
|
specified editor with a temporary file containing the macro's data.
|
|
922
|
specified editor with a temporary file containing the macro's data.
|
|
922
|
Upon exit, the macro is reloaded with the contents of the file.
|
|
923
|
Upon exit, the macro is reloaded with the contents of the file.
|
|
923
|
|
|
924
|
|
|
924
|
Note: opening at an exact line is only supported under Unix, and some
|
|
925
|
Note: opening at an exact line is only supported under Unix, and some
|
|
925
|
editors (like kedit and gedit up to Gnome 2.8) do not understand the
|
|
926
|
editors (like kedit and gedit up to Gnome 2.8) do not understand the
|
|
926
|
'+NUMBER' parameter necessary for this feature. Good editors like
|
|
927
|
'+NUMBER' parameter necessary for this feature. Good editors like
|
|
927
|
(X)Emacs, vi, jed, pico and joe all do.
|
|
928
|
(X)Emacs, vi, jed, pico and joe all do.
|
|
928
|
|
|
929
|
|
|
929
|
- If the argument is not found as a variable, IPython will look for a
|
|
930
|
- If the argument is not found as a variable, IPython will look for a
|
|
930
|
file with that name (adding .py if necessary) and load it into the
|
|
931
|
file with that name (adding .py if necessary) and load it into the
|
|
931
|
editor. It will execute its contents with execfile() when you exit,
|
|
932
|
editor. It will execute its contents with execfile() when you exit,
|
|
932
|
loading any code in the file into your interactive namespace.
|
|
933
|
loading any code in the file into your interactive namespace.
|
|
933
|
|
|
934
|
|
|
934
|
After executing your code, %edit will return as output the code you
|
|
935
|
After executing your code, %edit will return as output the code you
|
|
935
|
typed in the editor (except when it was an existing file). This way
|
|
936
|
typed in the editor (except when it was an existing file). This way
|
|
936
|
you can reload the code in further invocations of %edit as a variable,
|
|
937
|
you can reload the code in further invocations of %edit as a variable,
|
|
937
|
via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
|
|
938
|
via _<NUMBER> or Out[<NUMBER>], where <NUMBER> is the prompt number of
|
|
938
|
the output.
|
|
939
|
the output.
|
|
939
|
|
|
940
|
|
|
940
|
Note that %edit is also available through the alias %ed.
|
|
941
|
Note that %edit is also available through the alias %ed.
|
|
941
|
|
|
942
|
|
|
942
|
This is an example of creating a simple function inside the editor and
|
|
943
|
This is an example of creating a simple function inside the editor and
|
|
943
|
then modifying it. First, start up the editor:
|
|
944
|
then modifying it. First, start up the editor:
|
|
944
|
|
|
945
|
|
|
945
|
In [1]: ed\
|
|
946
|
In [1]: ed\
|
|
946
|
Editing... done. Executing edited code...\
|
|
947
|
Editing... done. Executing edited code...\
|
|
947
|
Out[1]: 'def foo():\n print "foo() was defined in an editing session"\n'
|
|
948
|
Out[1]: 'def foo():\n print "foo() was defined in an editing session"\n'
|
|
948
|
|
|
949
|
|
|
949
|
We can then call the function foo():
|
|
950
|
We can then call the function foo():
|
|
950
|
|
|
951
|
|
|
951
|
In [2]: foo()\
|
|
952
|
In [2]: foo()\
|
|
952
|
foo() was defined in an editing session
|
|
953
|
foo() was defined in an editing session
|
|
953
|
|
|
954
|
|
|
954
|
Now we edit foo. IPython automatically loads the editor with the
|
|
955
|
Now we edit foo. IPython automatically loads the editor with the
|
|
955
|
(temporary) file where foo() was previously defined:
|
|
956
|
(temporary) file where foo() was previously defined:
|
|
956
|
|
|
957
|
|
|
957
|
In [3]: ed foo\
|
|
958
|
In [3]: ed foo\
|
|
958
|
Editing... done. Executing edited code...
|
|
959
|
Editing... done. Executing edited code...
|
|
959
|
|
|
960
|
|
|
960
|
And if we call foo() again we get the modified version:
|
|
961
|
And if we call foo() again we get the modified version:
|
|
961
|
|
|
962
|
|
|
962
|
In [4]: foo()\
|
|
963
|
In [4]: foo()\
|
|
963
|
foo() has now been changed!
|
|
964
|
foo() has now been changed!
|
|
964
|
|
|
965
|
|
|
965
|
Here is an example of how to edit a code snippet successive
|
|
966
|
Here is an example of how to edit a code snippet successive
|
|
966
|
times. First we call the editor:
|
|
967
|
times. First we call the editor:
|
|
967
|
|
|
968
|
|
|
968
|
In [8]: ed\
|
|
969
|
In [8]: ed\
|
|
969
|
Editing... done. Executing edited code...\
|
|
970
|
Editing... done. Executing edited code...\
|
|
970
|
hello\
|
|
971
|
hello\
|
|
971
|
Out[8]: "print 'hello'\n"
|
|
972
|
Out[8]: "print 'hello'\n"
|
|
972
|
|
|
973
|
|
|
973
|
Now we call it again with the previous output (stored in _):
|
|
974
|
Now we call it again with the previous output (stored in _):
|
|
974
|
|
|
975
|
|
|
975
|
In [9]: ed _\
|
|
976
|
In [9]: ed _\
|
|
976
|
Editing... done. Executing edited code...\
|
|
977
|
Editing... done. Executing edited code...\
|
|
977
|
hello world\
|
|
978
|
hello world\
|
|
978
|
Out[9]: "print 'hello world'\n"
|
|
979
|
Out[9]: "print 'hello world'\n"
|
|
979
|
|
|
980
|
|
|
980
|
Now we call it with the output #8 (stored in _8, also as Out[8]):
|
|
981
|
Now we call it with the output #8 (stored in _8, also as Out[8]):
|
|
981
|
|
|
982
|
|
|
982
|
In [10]: ed _8\
|
|
983
|
In [10]: ed _8\
|
|
983
|
Editing... done. Executing edited code...\
|
|
984
|
Editing... done. Executing edited code...\
|
|
984
|
hello again\
|
|
985
|
hello again\
|
|
985
|
Out[10]: "print 'hello again'\n"
|
|
986
|
Out[10]: "print 'hello again'\n"
|
|
986
|
|
|
987
|
|
|
987
|
|
|
988
|
|
|
988
|
Changing the default editor hook:
|
|
989
|
Changing the default editor hook:
|
|
989
|
|
|
990
|
|
|
990
|
If you wish to write your own editor hook, you can put it in a
|
|
991
|
If you wish to write your own editor hook, you can put it in a
|
|
991
|
configuration file which you load at startup time. The default hook
|
|
992
|
configuration file which you load at startup time. The default hook
|
|
992
|
is defined in the IPython.hooks module, and you can use that as a
|
|
993
|
is defined in the IPython.hooks module, and you can use that as a
|
|
993
|
starting example for further modifications. That file also has
|
|
994
|
starting example for further modifications. That file also has
|
|
994
|
general instructions on how to set a new hook for use once you've
|
|
995
|
general instructions on how to set a new hook for use once you've
|
|
995
|
defined it.
|
|
996
|
defined it.
|
|
996
|
|
|
997
|
|
|
997
|
**%env**::
|
|
998
|
**%env**::
|
|
998
|
|
|
999
|
|
|
999
|
List environment variables.
|
|
1000
|
List environment variables.
|
|
1000
|
|
|
1001
|
|
|
1001
|
**%exit**::
|
|
1002
|
**%exit**::
|
|
1002
|
|
|
1003
|
|
|
1003
|
Exit IPython, confirming if configured to do so.
|
|
1004
|
Exit IPython, confirming if configured to do so.
|
|
1004
|
|
|
1005
|
|
|
1005
|
You can configure whether IPython asks for confirmation upon exit by
|
|
1006
|
You can configure whether IPython asks for confirmation upon exit by
|
|
1006
|
setting the confirm_exit flag in the ipythonrc file.
|
|
1007
|
setting the confirm_exit flag in the ipythonrc file.
|
|
1007
|
|
|
1008
|
|
|
1008
|
**%hist**::
|
|
1009
|
**%hist**::
|
|
1009
|
|
|
1010
|
|
|
1010
|
Alternate name for %history.
|
|
1011
|
Alternate name for %history.
|
|
1011
|
|
|
1012
|
|
|
1012
|
**%history**::
|
|
1013
|
**%history**::
|
|
1013
|
|
|
1014
|
|
|
1014
|
Print input history (_i<n> variables), with most recent last.
|
|
1015
|
Print input history (_i<n> variables), with most recent last.
|
|
1015
|
|
|
1016
|
|
|
1016
|
%history -> print at most 40 inputs (some may be multi-line)\
|
|
1017
|
%history -> print at most 40 inputs (some may be multi-line)\
|
|
1017
|
%history n -> print at most n inputs\
|
|
1018
|
%history n -> print at most n inputs\
|
|
1018
|
%history n1 n2 -> print inputs between n1 and n2 (n2 not included)\
|
|
1019
|
%history n1 n2 -> print inputs between n1 and n2 (n2 not included)\
|
|
1019
|
|
|
1020
|
|
|
1020
|
Each input's number <n> is shown, and is accessible as the
|
|
1021
|
Each input's number <n> is shown, and is accessible as the
|
|
1021
|
automatically generated variable _i<n>. Multi-line statements are
|
|
1022
|
automatically generated variable _i<n>. Multi-line statements are
|
|
1022
|
printed starting at a new line for easy copy/paste.
|
|
1023
|
printed starting at a new line for easy copy/paste.
|
|
1023
|
|
|
1024
|
|
|
1024
|
|
|
1025
|
|
|
1025
|
Options:
|
|
1026
|
Options:
|
|
1026
|
|
|
1027
|
|
|
1027
|
-n: do NOT print line numbers. This is useful if you want to get a
|
|
1028
|
-n: do NOT print line numbers. This is useful if you want to get a
|
|
1028
|
printout of many lines which can be directly pasted into a text
|
|
1029
|
printout of many lines which can be directly pasted into a text
|
|
1029
|
editor.
|
|
1030
|
editor.
|
|
1030
|
|
|
1031
|
|
|
1031
|
This feature is only available if numbered prompts are in use.
|
|
1032
|
This feature is only available if numbered prompts are in use.
|
|
1032
|
|
|
1033
|
|
|
1033
|
-t: (default) print the 'translated' history, as IPython understands it.
|
|
1034
|
-t: (default) print the 'translated' history, as IPython understands it.
|
|
1034
|
IPython filters your input and converts it all into valid Python source
|
|
1035
|
IPython filters your input and converts it all into valid Python source
|
|
1035
|
before executing it (things like magics or aliases are turned into
|
|
1036
|
before executing it (things like magics or aliases are turned into
|
|
1036
|
function calls, for example). With this option, you'll see the native
|
|
1037
|
function calls, for example). With this option, you'll see the native
|
|
1037
|
history instead of the user-entered version: '%cd /' will be seen as
|
|
1038
|
history instead of the user-entered version: '%cd /' will be seen as
|
|
1038
|
'_ip.magic("%cd /")' instead of '%cd /'.
|
|
1039
|
'_ip.magic("%cd /")' instead of '%cd /'.
|
|
1039
|
|
|
1040
|
|
|
1040
|
-r: print the 'raw' history, i.e. the actual commands you typed.
|
|
1041
|
-r: print the 'raw' history, i.e. the actual commands you typed.
|
|
1041
|
|
|
1042
|
|
|
1042
|
-g: treat the arg as a pattern to grep for in (full) history.
|
|
1043
|
-g: treat the arg as a pattern to grep for in (full) history.
|
|
1043
|
This includes the "shadow history" (almost all commands ever written).
|
|
1044
|
This includes the "shadow history" (almost all commands ever written).
|
|
1044
|
Use '%hist -g' to show full shadow history (may be very long).
|
|
1045
|
Use '%hist -g' to show full shadow history (may be very long).
|
|
1045
|
In shadow history, every index nuwber starts with 0.
|
|
1046
|
In shadow history, every index nuwber starts with 0.
|
|
1046
|
|
|
1047
|
|
|
1047
|
-f FILENAME: instead of printing the output to the screen, redirect it to
|
|
1048
|
-f FILENAME: instead of printing the output to the screen, redirect it to
|
|
1048
|
the given file. The file is always overwritten, though IPython asks for
|
|
1049
|
the given file. The file is always overwritten, though IPython asks for
|
|
1049
|
confirmation first if it already exists.
|
|
1050
|
confirmation first if it already exists.
|
|
1050
|
|
|
1051
|
|
|
1051
|
**%logoff**::
|
|
1052
|
**%logoff**::
|
|
1052
|
|
|
1053
|
|
|
1053
|
Temporarily stop logging.
|
|
1054
|
Temporarily stop logging.
|
|
1054
|
|
|
1055
|
|
|
1055
|
You must have previously started logging.
|
|
1056
|
You must have previously started logging.
|
|
1056
|
|
|
1057
|
|
|
1057
|
**%logon**::
|
|
1058
|
**%logon**::
|
|
1058
|
|
|
1059
|
|
|
1059
|
Restart logging.
|
|
1060
|
Restart logging.
|
|
1060
|
|
|
1061
|
|
|
1061
|
This function is for restarting logging which you've temporarily
|
|
1062
|
This function is for restarting logging which you've temporarily
|
|
1062
|
stopped with %logoff. For starting logging for the first time, you
|
|
1063
|
stopped with %logoff. For starting logging for the first time, you
|
|
1063
|
must use the %logstart function, which allows you to specify an
|
|
1064
|
must use the %logstart function, which allows you to specify an
|
|
1064
|
optional log filename.
|
|
1065
|
optional log filename.
|
|
1065
|
|
|
1066
|
|
|
1066
|
**%logstart**::
|
|
1067
|
**%logstart**::
|
|
1067
|
|
|
1068
|
|
|
1068
|
Start logging anywhere in a session.
|
|
1069
|
Start logging anywhere in a session.
|
|
1069
|
|
|
1070
|
|
|
1070
|
%logstart [-o|-r|-t] [log_name [log_mode]]
|
|
1071
|
%logstart [-o|-r|-t] [log_name [log_mode]]
|
|
1071
|
|
|
1072
|
|
|
1072
|
If no name is given, it defaults to a file named 'ipython_log.py' in your
|
|
1073
|
If no name is given, it defaults to a file named 'ipython_log.py' in your
|
|
1073
|
current directory, in 'rotate' mode (see below).
|
|
1074
|
current directory, in 'rotate' mode (see below).
|
|
1074
|
|
|
1075
|
|
|
1075
|
'%logstart name' saves to file 'name' in 'backup' mode. It saves your
|
|
1076
|
'%logstart name' saves to file 'name' in 'backup' mode. It saves your
|
|
1076
|
history up to that point and then continues logging.
|
|
1077
|
history up to that point and then continues logging.
|
|
1077
|
|
|
1078
|
|
|
1078
|
%logstart takes a second optional parameter: logging mode. This can be one
|
|
1079
|
%logstart takes a second optional parameter: logging mode. This can be one
|
|
1079
|
of (note that the modes are given unquoted):\
|
|
1080
|
of (note that the modes are given unquoted):\
|
|
1080
|
append: well, that says it.\
|
|
1081
|
append: well, that says it.\
|
|
1081
|
backup: rename (if exists) to name~ and start name.\
|
|
1082
|
backup: rename (if exists) to name~ and start name.\
|
|
1082
|
global: single logfile in your home dir, appended to.\
|
|
1083
|
global: single logfile in your home dir, appended to.\
|
|
1083
|
over : overwrite existing log.\
|
|
1084
|
over : overwrite existing log.\
|
|
1084
|
rotate: create rotating logs name.1~, name.2~, etc.
|
|
1085
|
rotate: create rotating logs name.1~, name.2~, etc.
|
|
1085
|
|
|
1086
|
|
|
1086
|
Options:
|
|
1087
|
Options:
|
|
1087
|
|
|
1088
|
|
|
1088
|
-o: log also IPython's output. In this mode, all commands which
|
|
1089
|
-o: log also IPython's output. In this mode, all commands which
|
|
1089
|
generate an Out[NN] prompt are recorded to the logfile, right after
|
|
1090
|
generate an Out[NN] prompt are recorded to the logfile, right after
|
|
1090
|
their corresponding input line. The output lines are always
|
|
1091
|
their corresponding input line. The output lines are always
|
|
1091
|
prepended with a '#[Out]# ' marker, so that the log remains valid
|
|
1092
|
prepended with a '#[Out]# ' marker, so that the log remains valid
|
|
1092
|
Python code.
|
|
1093
|
Python code.
|
|
1093
|
|
|
1094
|
|
|
1094
|
Since this marker is always the same, filtering only the output from
|
|
1095
|
Since this marker is always the same, filtering only the output from
|
|
1095
|
a log is very easy, using for example a simple awk call:
|
|
1096
|
a log is very easy, using for example a simple awk call:
|
|
1096
|
|
|
1097
|
|
|
1097
|
awk -F'#\[Out\]# ' '{if($2) {print $2}}' ipython_log.py
|
|
1098
|
awk -F'#\[Out\]# ' '{if($2) {print $2}}' ipython_log.py
|
|
1098
|
|
|
1099
|
|
|
1099
|
-r: log 'raw' input. Normally, IPython's logs contain the processed
|
|
1100
|
-r: log 'raw' input. Normally, IPython's logs contain the processed
|
|
1100
|
input, so that user lines are logged in their final form, converted
|
|
1101
|
input, so that user lines are logged in their final form, converted
|
|
1101
|
into valid Python. For example, %Exit is logged as
|
|
1102
|
into valid Python. For example, %Exit is logged as
|
|
1102
|
'_ip.magic("Exit"). If the -r flag is given, all input is logged
|
|
1103
|
'_ip.magic("Exit"). If the -r flag is given, all input is logged
|
|
1103
|
exactly as typed, with no transformations applied.
|
|
1104
|
exactly as typed, with no transformations applied.
|
|
1104
|
|
|
1105
|
|
|
1105
|
-t: put timestamps before each input line logged (these are put in
|
|
1106
|
-t: put timestamps before each input line logged (these are put in
|
|
1106
|
comments).
|
|
1107
|
comments).
|
|
1107
|
|
|
1108
|
|
|
1108
|
**%logstate**::
|
|
1109
|
**%logstate**::
|
|
1109
|
|
|
1110
|
|
|
1110
|
Print the status of the logging system.
|
|
1111
|
Print the status of the logging system.
|
|
1111
|
|
|
1112
|
|
|
1112
|
**%logstop**::
|
|
1113
|
**%logstop**::
|
|
1113
|
|
|
1114
|
|
|
1114
|
Fully stop logging and close log file.
|
|
1115
|
Fully stop logging and close log file.
|
|
1115
|
|
|
1116
|
|
|
1116
|
In order to start logging again, a new %logstart call needs to be made,
|
|
1117
|
In order to start logging again, a new %logstart call needs to be made,
|
|
1117
|
possibly (though not necessarily) with a new filename, mode and other
|
|
1118
|
possibly (though not necessarily) with a new filename, mode and other
|
|
1118
|
options.
|
|
1119
|
options.
|
|
1119
|
|
|
1120
|
|
|
1120
|
**%lsmagic**::
|
|
1121
|
**%lsmagic**::
|
|
1121
|
|
|
1122
|
|
|
1122
|
List currently available magic functions.
|
|
1123
|
List currently available magic functions.
|
|
1123
|
|
|
1124
|
|
|
1124
|
**%macro**::
|
|
1125
|
**%macro**::
|
|
1125
|
|
|
1126
|
|
|
1126
|
Define a set of input lines as a macro for future re-execution.
|
|
1127
|
Define a set of input lines as a macro for future re-execution.
|
|
1127
|
|
|
1128
|
|
|
1128
|
Usage:\
|
|
1129
|
Usage:\
|
|
1129
|
%macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
|
|
1130
|
%macro [options] name n1-n2 n3-n4 ... n5 .. n6 ...
|
|
1130
|
|
|
1131
|
|
|
1131
|
Options:
|
|
1132
|
Options:
|
|
1132
|
|
|
1133
|
|
|
1133
|
-r: use 'raw' input. By default, the 'processed' history is used,
|
|
1134
|
-r: use 'raw' input. By default, the 'processed' history is used,
|
|
1134
|
so that magics are loaded in their transformed version to valid
|
|
1135
|
so that magics are loaded in their transformed version to valid
|
|
1135
|
Python. If this option is given, the raw input as typed as the
|
|
1136
|
Python. If this option is given, the raw input as typed as the
|
|
1136
|
command line is used instead.
|
|
1137
|
command line is used instead.
|
|
1137
|
|
|
1138
|
|
|
1138
|
This will define a global variable called `name` which is a string
|
|
1139
|
This will define a global variable called `name` which is a string
|
|
1139
|
made of joining the slices and lines you specify (n1,n2,... numbers
|
|
1140
|
made of joining the slices and lines you specify (n1,n2,... numbers
|
|
1140
|
above) from your input history into a single string. This variable
|
|
1141
|
above) from your input history into a single string. This variable
|
|
1141
|
acts like an automatic function which re-executes those lines as if
|
|
1142
|
acts like an automatic function which re-executes those lines as if
|
|
1142
|
you had typed them. You just type 'name' at the prompt and the code
|
|
1143
|
you had typed them. You just type 'name' at the prompt and the code
|
|
1143
|
executes.
|
|
1144
|
executes.
|
|
1144
|
|
|
1145
|
|
|
1145
|
The notation for indicating number ranges is: n1-n2 means 'use line
|
|
1146
|
The notation for indicating number ranges is: n1-n2 means 'use line
|
|
1146
|
numbers n1,...n2' (the endpoint is included). That is, '5-7' means
|
|
1147
|
numbers n1,...n2' (the endpoint is included). That is, '5-7' means
|
|
1147
|
using the lines numbered 5,6 and 7.
|
|
1148
|
using the lines numbered 5,6 and 7.
|
|
1148
|
|
|
1149
|
|
|
1149
|
Note: as a 'hidden' feature, you can also use traditional python slice
|
|
1150
|
Note: as a 'hidden' feature, you can also use traditional python slice
|
|
1150
|
notation, where N:M means numbers N through M-1.
|
|
1151
|
notation, where N:M means numbers N through M-1.
|
|
1151
|
|
|
1152
|
|
|
1152
|
For example, if your history contains (%hist prints it):
|
|
1153
|
For example, if your history contains (%hist prints it):
|
|
1153
|
|
|
1154
|
|
|
1154
|
44: x=1\
|
|
1155
|
44: x=1\
|
|
1155
|
45: y=3\
|
|
1156
|
45: y=3\
|
|
1156
|
46: z=x+y\
|
|
1157
|
46: z=x+y\
|
|
1157
|
47: print x\
|
|
1158
|
47: print x\
|
|
1158
|
48: a=5\
|
|
1159
|
48: a=5\
|
|
1159
|
49: print 'x',x,'y',y\
|
|
1160
|
49: print 'x',x,'y',y\
|
|
1160
|
|
|
1161
|
|
|
1161
|
you can create a macro with lines 44 through 47 (included) and line 49
|
|
1162
|
you can create a macro with lines 44 through 47 (included) and line 49
|
|
1162
|
called my_macro with:
|
|
1163
|
called my_macro with:
|
|
1163
|
|
|
1164
|
|
|
1164
|
In [51]: %macro my_macro 44-47 49
|
|
1165
|
In [51]: %macro my_macro 44-47 49
|
|
1165
|
|
|
1166
|
|
|
1166
|
Now, typing `my_macro` (without quotes) will re-execute all this code
|
|
1167
|
Now, typing `my_macro` (without quotes) will re-execute all this code
|
|
1167
|
in one pass.
|
|
1168
|
in one pass.
|
|
1168
|
|
|
1169
|
|
|
1169
|
You don't need to give the line-numbers in order, and any given line
|
|
1170
|
You don't need to give the line-numbers in order, and any given line
|
|
1170
|
number can appear multiple times. You can assemble macros with any
|
|
1171
|
number can appear multiple times. You can assemble macros with any
|
|
1171
|
lines from your input history in any order.
|
|
1172
|
lines from your input history in any order.
|
|
1172
|
|
|
1173
|
|
|
1173
|
The macro is a simple object which holds its value in an attribute,
|
|
1174
|
The macro is a simple object which holds its value in an attribute,
|
|
1174
|
but IPython's display system checks for macros and executes them as
|
|
1175
|
but IPython's display system checks for macros and executes them as
|
|
1175
|
code instead of printing them when you type their name.
|
|
1176
|
code instead of printing them when you type their name.
|
|
1176
|
|
|
1177
|
|
|
1177
|
You can view a macro's contents by explicitly printing it with:
|
|
1178
|
You can view a macro's contents by explicitly printing it with:
|
|
1178
|
|
|
1179
|
|
|
1179
|
'print macro_name'.
|
|
1180
|
'print macro_name'.
|
|
1180
|
|
|
1181
|
|
|
1181
|
For one-off cases which DON'T contain magic function calls in them you
|
|
1182
|
For one-off cases which DON'T contain magic function calls in them you
|
|
1182
|
can obtain similar results by explicitly executing slices from your
|
|
1183
|
can obtain similar results by explicitly executing slices from your
|
|
1183
|
input history with:
|
|
1184
|
input history with:
|
|
1184
|
|
|
1185
|
|
|
1185
|
In [60]: exec In[44:48]+In[49]
|
|
1186
|
In [60]: exec In[44:48]+In[49]
|
|
1186
|
|
|
1187
|
|
|
1187
|
**%magic**::
|
|
1188
|
**%magic**::
|
|
1188
|
|
|
1189
|
|
|
1189
|
Print information about the magic function system.
|
|
1190
|
Print information about the magic function system.
|
|
1190
|
|
|
1191
|
|
|
1191
|
**%mglob**::
|
|
1192
|
**%mglob**::
|
|
1192
|
|
|
1193
|
|
|
1193
|
This program allows specifying filenames with "mglob" mechanism.
|
|
1194
|
This program allows specifying filenames with "mglob" mechanism.
|
|
1194
|
Supported syntax in globs (wilcard matching patterns)::
|
|
1195
|
Supported syntax in globs (wilcard matching patterns)::
|
|
1195
|
|
|
1196
|
|
|
1196
|
*.cpp ?ellowo*
|
|
1197
|
*.cpp ?ellowo*
|
|
1197
|
- obvious. Differs from normal glob in that dirs are not included.
|
|
1198
|
- obvious. Differs from normal glob in that dirs are not included.
|
|
1198
|
Unix users might want to write this as: "*.cpp" "?ellowo*"
|
|
1199
|
Unix users might want to write this as: "*.cpp" "?ellowo*"
|
|
1199
|
rec:/usr/share=*.txt,*.doc
|
|
1200
|
rec:/usr/share=*.txt,*.doc
|
|
1200
|
- get all *.txt and *.doc under /usr/share,
|
|
1201
|
- get all *.txt and *.doc under /usr/share,
|
|
1201
|
recursively
|
|
1202
|
recursively
|
|
1202
|
rec:/usr/share
|
|
1203
|
rec:/usr/share
|
|
1203
|
- All files under /usr/share, recursively
|
|
1204
|
- All files under /usr/share, recursively
|
|
1204
|
rec:*.py
|
|
1205
|
rec:*.py
|
|
1205
|
- All .py files under current working dir, recursively
|
|
1206
|
- All .py files under current working dir, recursively
|
|
1206
|
foo
|
|
1207
|
foo
|
|
1207
|
- File or dir foo
|
|
1208
|
- File or dir foo
|
|
1208
|
!*.bak readme*
|
|
1209
|
!*.bak readme*
|
|
1209
|
- readme*, exclude files ending with .bak
|
|
1210
|
- readme*, exclude files ending with .bak
|
|
1210
|
!.svn/ !.hg/ !*_Data/ rec:.
|
|
1211
|
!.svn/ !.hg/ !*_Data/ rec:.
|
|
1211
|
- Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
|
|
1212
|
- Skip .svn, .hg, foo_Data dirs (and their subdirs) in recurse.
|
|
1212
|
Trailing / is the key, \ does not work!
|
|
1213
|
Trailing / is the key, \ does not work!
|
|
1213
|
dir:foo
|
|
1214
|
dir:foo
|
|
1214
|
- the directory foo if it exists (not files in foo)
|
|
1215
|
- the directory foo if it exists (not files in foo)
|
|
1215
|
dir:*
|
|
1216
|
dir:*
|
|
1216
|
- all directories in current folder
|
|
1217
|
- all directories in current folder
|
|
1217
|
foo.py bar.* !h* rec:*.py
|
|
1218
|
foo.py bar.* !h* rec:*.py
|
|
1218
|
- Obvious. !h* exclusion only applies for rec:*.py.
|
|
1219
|
- Obvious. !h* exclusion only applies for rec:*.py.
|
|
1219
|
foo.py is *not* included twice.
|
|
1220
|
foo.py is *not* included twice.
|
|
1220
|
@filelist.txt
|
|
1221
|
@filelist.txt
|
|
1221
|
- All files listed in 'filelist.txt' file, on separate lines.
|
|
1222
|
- All files listed in 'filelist.txt' file, on separate lines.
|
|
1222
|
|
|
1223
|
|
|
1223
|
**%page**::
|
|
1224
|
**%page**::
|
|
1224
|
|
|
1225
|
|
|
1225
|
Pretty print the object and display it through a pager.
|
|
1226
|
Pretty print the object and display it through a pager.
|
|
1226
|
|
|
1227
|
|
|
1227
|
%page [options] OBJECT
|
|
1228
|
%page [options] OBJECT
|
|
1228
|
|
|
1229
|
|
|
1229
|
If no object is given, use _ (last output).
|
|
1230
|
If no object is given, use _ (last output).
|
|
1230
|
|
|
1231
|
|
|
1231
|
Options:
|
|
1232
|
Options:
|
|
1232
|
|
|
1233
|
|
|
1233
|
-r: page str(object), don't pretty-print it.
|
|
1234
|
-r: page str(object), don't pretty-print it.
|
|
1234
|
|
|
1235
|
|
|
1235
|
**%pdb**::
|
|
1236
|
**%pdb**::
|
|
1236
|
|
|
1237
|
|
|
1237
|
Control the automatic calling of the pdb interactive debugger.
|
|
1238
|
Control the automatic calling of the pdb interactive debugger.
|
|
1238
|
|
|
1239
|
|
|
1239
|
Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
|
|
1240
|
Call as '%pdb on', '%pdb 1', '%pdb off' or '%pdb 0'. If called without
|
|
1240
|
argument it works as a toggle.
|
|
1241
|
argument it works as a toggle.
|
|
1241
|
|
|
1242
|
|
|
1242
|
When an exception is triggered, IPython can optionally call the
|
|
1243
|
When an exception is triggered, IPython can optionally call the
|
|
1243
|
interactive pdb debugger after the traceback printout. %pdb toggles
|
|
1244
|
interactive pdb debugger after the traceback printout. %pdb toggles
|
|
1244
|
this feature on and off.
|
|
1245
|
this feature on and off.
|
|
1245
|
|
|
1246
|
|
|
1246
|
The initial state of this feature is set in your ipythonrc
|
|
1247
|
The initial state of this feature is set in your ipythonrc
|
|
1247
|
configuration file (the variable is called 'pdb').
|
|
1248
|
configuration file (the variable is called 'pdb').
|
|
1248
|
|
|
1249
|
|
|
1249
|
If you want to just activate the debugger AFTER an exception has fired,
|
|
1250
|
If you want to just activate the debugger AFTER an exception has fired,
|
|
1250
|
without having to type '%pdb on' and rerunning your code, you can use
|
|
1251
|
without having to type '%pdb on' and rerunning your code, you can use
|
|
1251
|
the %debug magic.
|
|
1252
|
the %debug magic.
|
|
1252
|
|
|
1253
|
|
|
1253
|
**%pdef**::
|
|
1254
|
**%pdef**::
|
|
1254
|
|
|
1255
|
|
|
1255
|
Print the definition header for any callable object.
|
|
1256
|
Print the definition header for any callable object.
|
|
1256
|
|
|
1257
|
|
|
1257
|
If the object is a class, print the constructor information.
|
|
1258
|
If the object is a class, print the constructor information.
|
|
1258
|
|
|
1259
|
|
|
1259
|
**%pdoc**::
|
|
1260
|
**%pdoc**::
|
|
1260
|
|
|
1261
|
|
|
1261
|
Print the docstring for an object.
|
|
1262
|
Print the docstring for an object.
|
|
1262
|
|
|
1263
|
|
|
1263
|
If the given object is a class, it will print both the class and the
|
|
1264
|
If the given object is a class, it will print both the class and the
|
|
1264
|
constructor docstrings.
|
|
1265
|
constructor docstrings.
|
|
1265
|
|
|
1266
|
|
|
1266
|
**%pfile**::
|
|
1267
|
**%pfile**::
|
|
1267
|
|
|
1268
|
|
|
1268
|
Print (or run through pager) the file where an object is defined.
|
|
1269
|
Print (or run through pager) the file where an object is defined.
|
|
1269
|
|
|
1270
|
|
|
1270
|
The file opens at the line where the object definition begins. IPython
|
|
1271
|
The file opens at the line where the object definition begins. IPython
|
|
1271
|
will honor the environment variable PAGER if set, and otherwise will
|
|
1272
|
will honor the environment variable PAGER if set, and otherwise will
|
|
1272
|
do its best to print the file in a convenient form.
|
|
1273
|
do its best to print the file in a convenient form.
|
|
1273
|
|
|
1274
|
|
|
1274
|
If the given argument is not an object currently defined, IPython will
|
|
1275
|
If the given argument is not an object currently defined, IPython will
|
|
1275
|
try to interpret it as a filename (automatically adding a .py extension
|
|
1276
|
try to interpret it as a filename (automatically adding a .py extension
|
|
1276
|
if needed). You can thus use %pfile as a syntax highlighting code
|
|
1277
|
if needed). You can thus use %pfile as a syntax highlighting code
|
|
1277
|
viewer.
|
|
1278
|
viewer.
|
|
1278
|
|
|
1279
|
|
|
1279
|
**%pinfo**::
|
|
1280
|
**%pinfo**::
|
|
1280
|
|
|
1281
|
|
|
1281
|
Provide detailed information about an object.
|
|
1282
|
Provide detailed information about an object.
|
|
1282
|
|
|
1283
|
|
|
1283
|
'%pinfo object' is just a synonym for object? or ?object.
|
|
1284
|
'%pinfo object' is just a synonym for object? or ?object.
|
|
1284
|
|
|
1285
|
|
|
1285
|
**%popd**::
|
|
1286
|
**%popd**::
|
|
1286
|
|
|
1287
|
|
|
1287
|
Change to directory popped off the top of the stack.
|
|
1288
|
Change to directory popped off the top of the stack.
|
|
1288
|
|
|
1289
|
|
|
1289
|
**%profile**::
|
|
1290
|
**%profile**::
|
|
1290
|
|
|
1291
|
|
|
1291
|
Print your currently active IPyhton profile.
|
|
1292
|
Print your currently active IPyhton profile.
|
|
1292
|
|
|
1293
|
|
|
1293
|
**%prun**::
|
|
1294
|
**%prun**::
|
|
1294
|
|
|
1295
|
|
|
1295
|
Run a statement through the python code profiler.
|
|
1296
|
Run a statement through the python code profiler.
|
|
1296
|
|
|
1297
|
|
|
1297
|
Usage:\
|
|
1298
|
Usage:\
|
|
1298
|
%prun [options] statement
|
|
1299
|
%prun [options] statement
|
|
1299
|
|
|
1300
|
|
|
1300
|
The given statement (which doesn't require quote marks) is run via the
|
|
1301
|
The given statement (which doesn't require quote marks) is run via the
|
|
1301
|
python profiler in a manner similar to the profile.run() function.
|
|
1302
|
python profiler in a manner similar to the profile.run() function.
|
|
1302
|
Namespaces are internally managed to work correctly; profile.run
|
|
1303
|
Namespaces are internally managed to work correctly; profile.run
|
|
1303
|
cannot be used in IPython because it makes certain assumptions about
|
|
1304
|
cannot be used in IPython because it makes certain assumptions about
|
|
1304
|
namespaces which do not hold under IPython.
|
|
1305
|
namespaces which do not hold under IPython.
|
|
1305
|
|
|
1306
|
|
|
1306
|
Options:
|
|
1307
|
Options:
|
|
1307
|
|
|
1308
|
|
|
1308
|
-l <limit>: you can place restrictions on what or how much of the
|
|
1309
|
-l <limit>: you can place restrictions on what or how much of the
|
|
1309
|
profile gets printed. The limit value can be:
|
|
1310
|
profile gets printed. The limit value can be:
|
|
1310
|
|
|
1311
|
|
|
1311
|
* A string: only information for function names containing this string
|
|
1312
|
* A string: only information for function names containing this string
|
|
1312
|
is printed.
|
|
1313
|
is printed.
|
|
1313
|
|
|
1314
|
|
|
1314
|
* An integer: only these many lines are printed.
|
|
1315
|
* An integer: only these many lines are printed.
|
|
1315
|
|
|
1316
|
|
|
1316
|
* A float (between 0 and 1): this fraction of the report is printed
|
|
1317
|
* A float (between 0 and 1): this fraction of the report is printed
|
|
1317
|
(for example, use a limit of 0.4 to see the topmost 40% only).
|
|
1318
|
(for example, use a limit of 0.4 to see the topmost 40% only).
|
|
1318
|
|
|
1319
|
|
|
1319
|
You can combine several limits with repeated use of the option. For
|
|
1320
|
You can combine several limits with repeated use of the option. For
|
|
1320
|
example, '-l __init__ -l 5' will print only the topmost 5 lines of
|
|
1321
|
example, '-l __init__ -l 5' will print only the topmost 5 lines of
|
|
1321
|
information about class constructors.
|
|
1322
|
information about class constructors.
|
|
1322
|
|
|
1323
|
|
|
1323
|
-r: return the pstats.Stats object generated by the profiling. This
|
|
1324
|
-r: return the pstats.Stats object generated by the profiling. This
|
|
1324
|
object has all the information about the profile in it, and you can
|
|
1325
|
object has all the information about the profile in it, and you can
|
|
1325
|
later use it for further analysis or in other functions.
|
|
1326
|
later use it for further analysis or in other functions.
|
|
1326
|
|
|
1327
|
|
|
1327
|
-s <key>: sort profile by given key. You can provide more than one key
|
|
1328
|
-s <key>: sort profile by given key. You can provide more than one key
|
|
1328
|
by using the option several times: '-s key1 -s key2 -s key3...'. The
|
|
1329
|
by using the option several times: '-s key1 -s key2 -s key3...'. The
|
|
1329
|
default sorting key is 'time'.
|
|
1330
|
default sorting key is 'time'.
|
|
1330
|
|
|
1331
|
|
|
1331
|
The following is copied verbatim from the profile documentation
|
|
1332
|
The following is copied verbatim from the profile documentation
|
|
1332
|
referenced below:
|
|
1333
|
referenced below:
|
|
1333
|
|
|
1334
|
|
|
1334
|
When more than one key is provided, additional keys are used as
|
|
1335
|
When more than one key is provided, additional keys are used as
|
|
1335
|
secondary criteria when the there is equality in all keys selected
|
|
1336
|
secondary criteria when the there is equality in all keys selected
|
|
1336
|
before them.
|
|
1337
|
before them.
|
|
1337
|
|
|
1338
|
|
|
1338
|
Abbreviations can be used for any key names, as long as the
|
|
1339
|
Abbreviations can be used for any key names, as long as the
|
|
1339
|
abbreviation is unambiguous. The following are the keys currently
|
|
1340
|
abbreviation is unambiguous. The following are the keys currently
|
|
1340
|
defined:
|
|
1341
|
defined:
|
|
1341
|
|
|
1342
|
|
|
1342
|
Valid Arg Meaning\
|
|
1343
|
Valid Arg Meaning\
|
|
1343
|
"calls" call count\
|
|
1344
|
"calls" call count\
|
|
1344
|
"cumulative" cumulative time\
|
|
1345
|
"cumulative" cumulative time\
|
|
1345
|
"file" file name\
|
|
1346
|
"file" file name\
|
|
1346
|
"module" file name\
|
|
1347
|
"module" file name\
|
|
1347
|
"pcalls" primitive call count\
|
|
1348
|
"pcalls" primitive call count\
|
|
1348
|
"line" line number\
|
|
1349
|
"line" line number\
|
|
1349
|
"name" function name\
|
|
1350
|
"name" function name\
|
|
1350
|
"nfl" name/file/line\
|
|
1351
|
"nfl" name/file/line\
|
|
1351
|
"stdname" standard name\
|
|
1352
|
"stdname" standard name\
|
|
1352
|
"time" internal time
|
|
1353
|
"time" internal time
|
|
1353
|
|
|
1354
|
|
|
1354
|
Note that all sorts on statistics are in descending order (placing
|
|
1355
|
Note that all sorts on statistics are in descending order (placing
|
|
1355
|
most time consuming items first), where as name, file, and line number
|
|
1356
|
most time consuming items first), where as name, file, and line number
|
|
1356
|
searches are in ascending order (i.e., alphabetical). The subtle
|
|
1357
|
searches are in ascending order (i.e., alphabetical). The subtle
|
|
1357
|
distinction between "nfl" and "stdname" is that the standard name is a
|
|
1358
|
distinction between "nfl" and "stdname" is that the standard name is a
|
|
1358
|
sort of the name as printed, which means that the embedded line
|
|
1359
|
sort of the name as printed, which means that the embedded line
|
|
1359
|
numbers get compared in an odd way. For example, lines 3, 20, and 40
|
|
1360
|
numbers get compared in an odd way. For example, lines 3, 20, and 40
|
|
1360
|
would (if the file names were the same) appear in the string order
|
|
1361
|
would (if the file names were the same) appear in the string order
|
|
1361
|
"20" "3" and "40". In contrast, "nfl" does a numeric compare of the
|
|
1362
|
"20" "3" and "40". In contrast, "nfl" does a numeric compare of the
|
|
1362
|
line numbers. In fact, sort_stats("nfl") is the same as
|
|
1363
|
line numbers. In fact, sort_stats("nfl") is the same as
|
|
1363
|
sort_stats("name", "file", "line").
|
|
1364
|
sort_stats("name", "file", "line").
|
|
1364
|
|
|
1365
|
|
|
1365
|
-T <filename>: save profile results as shown on screen to a text
|
|
1366
|
-T <filename>: save profile results as shown on screen to a text
|
|
1366
|
file. The profile is still shown on screen.
|
|
1367
|
file. The profile is still shown on screen.
|
|
1367
|
|
|
1368
|
|
|
1368
|
-D <filename>: save (via dump_stats) profile statistics to given
|
|
1369
|
-D <filename>: save (via dump_stats) profile statistics to given
|
|
1369
|
filename. This data is in a format understod by the pstats module, and
|
|
1370
|
filename. This data is in a format understod by the pstats module, and
|
|
1370
|
is generated by a call to the dump_stats() method of profile
|
|
1371
|
is generated by a call to the dump_stats() method of profile
|
|
1371
|
objects. The profile is still shown on screen.
|
|
1372
|
objects. The profile is still shown on screen.
|
|
1372
|
|
|
1373
|
|
|
1373
|
If you want to run complete programs under the profiler's control, use
|
|
1374
|
If you want to run complete programs under the profiler's control, use
|
|
1374
|
'%run -p [prof_opts] filename.py [args to program]' where prof_opts
|
|
1375
|
'%run -p [prof_opts] filename.py [args to program]' where prof_opts
|
|
1375
|
contains profiler specific options as described here.
|
|
1376
|
contains profiler specific options as described here.
|
|
1376
|
|
|
1377
|
|
|
1377
|
You can read the complete documentation for the profile module with:\
|
|
1378
|
You can read the complete documentation for the profile module with:\
|
|
1378
|
In [1]: import profile; profile.help()
|
|
1379
|
In [1]: import profile; profile.help()
|
|
1379
|
|
|
1380
|
|
|
1380
|
**%psearch**::
|
|
1381
|
**%psearch**::
|
|
1381
|
|
|
1382
|
|
|
1382
|
Search for object in namespaces by wildcard.
|
|
1383
|
Search for object in namespaces by wildcard.
|
|
1383
|
|
|
1384
|
|
|
1384
|
%psearch [options] PATTERN [OBJECT TYPE]
|
|
1385
|
%psearch [options] PATTERN [OBJECT TYPE]
|
|
1385
|
|
|
1386
|
|
|
1386
|
Note: ? can be used as a synonym for %psearch, at the beginning or at
|
|
1387
|
Note: ? can be used as a synonym for %psearch, at the beginning or at
|
|
1387
|
the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
|
|
1388
|
the end: both a*? and ?a* are equivalent to '%psearch a*'. Still, the
|
|
1388
|
rest of the command line must be unchanged (options come first), so
|
|
1389
|
rest of the command line must be unchanged (options come first), so
|
|
1389
|
for example the following forms are equivalent
|
|
1390
|
for example the following forms are equivalent
|
|
1390
|
|
|
1391
|
|
|
1391
|
%psearch -i a* function
|
|
1392
|
%psearch -i a* function
|
|
1392
|
-i a* function?
|
|
1393
|
-i a* function?
|
|
1393
|
?-i a* function
|
|
1394
|
?-i a* function
|
|
1394
|
|
|
1395
|
|
|
1395
|
Arguments:
|
|
1396
|
Arguments:
|
|
1396
|
|
|
1397
|
|
|
1397
|
PATTERN
|
|
1398
|
PATTERN
|
|
1398
|
|
|
1399
|
|
|
1399
|
where PATTERN is a string containing * as a wildcard similar to its
|
|
1400
|
where PATTERN is a string containing * as a wildcard similar to its
|
|
1400
|
use in a shell. The pattern is matched in all namespaces on the
|
|
1401
|
use in a shell. The pattern is matched in all namespaces on the
|
|
1401
|
search path. By default objects starting with a single _ are not
|
|
1402
|
search path. By default objects starting with a single _ are not
|
|
1402
|
matched, many IPython generated objects have a single
|
|
1403
|
matched, many IPython generated objects have a single
|
|
1403
|
underscore. The default is case insensitive matching. Matching is
|
|
1404
|
underscore. The default is case insensitive matching. Matching is
|
|
1404
|
also done on the attributes of objects and not only on the objects
|
|
1405
|
also done on the attributes of objects and not only on the objects
|
|
1405
|
in a module.
|
|
1406
|
in a module.
|
|
1406
|
|
|
1407
|
|
|
1407
|
[OBJECT TYPE]
|
|
1408
|
[OBJECT TYPE]
|
|
1408
|
|
|
1409
|
|
|
1409
|
Is the name of a python type from the types module. The name is
|
|
1410
|
Is the name of a python type from the types module. The name is
|
|
1410
|
given in lowercase without the ending type, ex. StringType is
|
|
1411
|
given in lowercase without the ending type, ex. StringType is
|
|
1411
|
written string. By adding a type here only objects matching the
|
|
1412
|
written string. By adding a type here only objects matching the
|
|
1412
|
given type are matched. Using all here makes the pattern match all
|
|
1413
|
given type are matched. Using all here makes the pattern match all
|
|
1413
|
types (this is the default).
|
|
1414
|
types (this is the default).
|
|
1414
|
|
|
1415
|
|
|
1415
|
Options:
|
|
1416
|
Options:
|
|
1416
|
|
|
1417
|
|
|
1417
|
-a: makes the pattern match even objects whose names start with a
|
|
1418
|
-a: makes the pattern match even objects whose names start with a
|
|
1418
|
single underscore. These names are normally ommitted from the
|
|
1419
|
single underscore. These names are normally ommitted from the
|
|
1419
|
search.
|
|
1420
|
search.
|
|
1420
|
|
|
1421
|
|
|
1421
|
-i/-c: make the pattern case insensitive/sensitive. If neither of
|
|
1422
|
-i/-c: make the pattern case insensitive/sensitive. If neither of
|
|
1422
|
these options is given, the default is read from your ipythonrc
|
|
1423
|
these options is given, the default is read from your ipythonrc
|
|
1423
|
file. The option name which sets this value is
|
|
1424
|
file. The option name which sets this value is
|
|
1424
|
'wildcards_case_sensitive'. If this option is not specified in your
|
|
1425
|
'wildcards_case_sensitive'. If this option is not specified in your
|
|
1425
|
ipythonrc file, IPython's internal default is to do a case sensitive
|
|
1426
|
ipythonrc file, IPython's internal default is to do a case sensitive
|
|
1426
|
search.
|
|
1427
|
search.
|
|
1427
|
|
|
1428
|
|
|
1428
|
-e/-s NAMESPACE: exclude/search a given namespace. The pattern you
|
|
1429
|
-e/-s NAMESPACE: exclude/search a given namespace. The pattern you
|
|
1429
|
specifiy can be searched in any of the following namespaces:
|
|
1430
|
specifiy can be searched in any of the following namespaces:
|
|
1430
|
'builtin', 'user', 'user_global','internal', 'alias', where
|
|
1431
|
'builtin', 'user', 'user_global','internal', 'alias', where
|
|
1431
|
'builtin' and 'user' are the search defaults. Note that you should
|
|
1432
|
'builtin' and 'user' are the search defaults. Note that you should
|
|
1432
|
not use quotes when specifying namespaces.
|
|
1433
|
not use quotes when specifying namespaces.
|
|
1433
|
|
|
1434
|
|
|
1434
|
'Builtin' contains the python module builtin, 'user' contains all
|
|
1435
|
'Builtin' contains the python module builtin, 'user' contains all
|
|
1435
|
user data, 'alias' only contain the shell aliases and no python
|
|
1436
|
user data, 'alias' only contain the shell aliases and no python
|
|
1436
|
objects, 'internal' contains objects used by IPython. The
|
|
1437
|
objects, 'internal' contains objects used by IPython. The
|
|
1437
|
'user_global' namespace is only used by embedded IPython instances,
|
|
1438
|
'user_global' namespace is only used by embedded IPython instances,
|
|
1438
|
and it contains module-level globals. You can add namespaces to the
|
|
1439
|
and it contains module-level globals. You can add namespaces to the
|
|
1439
|
search with -s or exclude them with -e (these options can be given
|
|
1440
|
search with -s or exclude them with -e (these options can be given
|
|
1440
|
more than once).
|
|
1441
|
more than once).
|
|
1441
|
|
|
1442
|
|
|
1442
|
Examples:
|
|
1443
|
Examples:
|
|
1443
|
|
|
1444
|
|
|
1444
|
%psearch a* -> objects beginning with an a
|
|
1445
|
%psearch a* -> objects beginning with an a
|
|
1445
|
%psearch -e builtin a* -> objects NOT in the builtin space starting in a
|
|
1446
|
%psearch -e builtin a* -> objects NOT in the builtin space starting in a
|
|
1446
|
%psearch a* function -> all functions beginning with an a
|
|
1447
|
%psearch a* function -> all functions beginning with an a
|
|
1447
|
%psearch re.e* -> objects beginning with an e in module re
|
|
1448
|
%psearch re.e* -> objects beginning with an e in module re
|
|
1448
|
%psearch r*.e* -> objects that start with e in modules starting in r
|
|
1449
|
%psearch r*.e* -> objects that start with e in modules starting in r
|
|
1449
|
%psearch r*.* string -> all strings in modules beginning with r
|
|
1450
|
%psearch r*.* string -> all strings in modules beginning with r
|
|
1450
|
|
|
1451
|
|
|
1451
|
Case sensitve search:
|
|
1452
|
Case sensitve search:
|
|
1452
|
|
|
1453
|
|
|
1453
|
%psearch -c a* list all object beginning with lower case a
|
|
1454
|
%psearch -c a* list all object beginning with lower case a
|
|
1454
|
|
|
1455
|
|
|
1455
|
Show objects beginning with a single _:
|
|
1456
|
Show objects beginning with a single _:
|
|
1456
|
|
|
1457
|
|
|
1457
|
%psearch -a _* list objects beginning with a single underscore
|
|
1458
|
%psearch -a _* list objects beginning with a single underscore
|
|
1458
|
|
|
1459
|
|
|
1459
|
**%psource**::
|
|
1460
|
**%psource**::
|
|
1460
|
|
|
1461
|
|
|
1461
|
Print (or run through pager) the source code for an object.
|
|
1462
|
Print (or run through pager) the source code for an object.
|
|
1462
|
|
|
1463
|
|
|
1463
|
**%pushd**::
|
|
1464
|
**%pushd**::
|
|
1464
|
|
|
1465
|
|
|
1465
|
Place the current dir on stack and change directory.
|
|
1466
|
Place the current dir on stack and change directory.
|
|
1466
|
|
|
1467
|
|
|
1467
|
Usage:\
|
|
1468
|
Usage:\
|
|
1468
|
%pushd ['dirname']
|
|
1469
|
%pushd ['dirname']
|
|
1469
|
|
|
1470
|
|
|
1470
|
**%pwd**::
|
|
1471
|
**%pwd**::
|
|
1471
|
|
|
1472
|
|
|
1472
|
Return the current working directory path.
|
|
1473
|
Return the current working directory path.
|
|
1473
|
|
|
1474
|
|
|
1474
|
**%pycat**::
|
|
1475
|
**%pycat**::
|
|
1475
|
|
|
1476
|
|
|
1476
|
Show a syntax-highlighted file through a pager.
|
|
1477
|
Show a syntax-highlighted file through a pager.
|
|
1477
|
|
|
1478
|
|
|
1478
|
This magic is similar to the cat utility, but it will assume the file
|
|
1479
|
This magic is similar to the cat utility, but it will assume the file
|
|
1479
|
to be Python source and will show it with syntax highlighting.
|
|
1480
|
to be Python source and will show it with syntax highlighting.
|
|
1480
|
|
|
1481
|
|
|
1481
|
**%quickref**::
|
|
1482
|
**%quickref**::
|
|
1482
|
|
|
1483
|
|
|
1483
|
Show a quick reference sheet
|
|
1484
|
Show a quick reference sheet
|
|
1484
|
|
|
1485
|
|
|
1485
|
**%quit**::
|
|
1486
|
**%quit**::
|
|
1486
|
|
|
1487
|
|
|
1487
|
Exit IPython, confirming if configured to do so (like %exit)
|
|
1488
|
Exit IPython, confirming if configured to do so (like %exit)
|
|
1488
|
|
|
1489
|
|
|
1489
|
**%r**::
|
|
1490
|
**%r**::
|
|
1490
|
|
|
1491
|
|
|
1491
|
Repeat previous input.
|
|
1492
|
Repeat previous input.
|
|
1492
|
|
|
1493
|
|
|
1493
|
Note: Consider using the more powerfull %rep instead!
|
|
1494
|
Note: Consider using the more powerfull %rep instead!
|
|
1494
|
|
|
1495
|
|
|
1495
|
If given an argument, repeats the previous command which starts with
|
|
1496
|
If given an argument, repeats the previous command which starts with
|
|
1496
|
the same string, otherwise it just repeats the previous input.
|
|
1497
|
the same string, otherwise it just repeats the previous input.
|
|
1497
|
|
|
1498
|
|
|
1498
|
Shell escaped commands (with ! as first character) are not recognized
|
|
1499
|
Shell escaped commands (with ! as first character) are not recognized
|
|
1499
|
by this system, only pure python code and magic commands.
|
|
1500
|
by this system, only pure python code and magic commands.
|
|
1500
|
|
|
1501
|
|
|
1501
|
**%rehashdir**::
|
|
1502
|
**%rehashdir**::
|
|
1502
|
|
|
1503
|
|
|
1503
|
Add executables in all specified dirs to alias table
|
|
1504
|
Add executables in all specified dirs to alias table
|
|
1504
|
|
|
1505
|
|
|
1505
|
Usage:
|
|
1506
|
Usage:
|
|
1506
|
|
|
1507
|
|
|
1507
|
%rehashdir c:/bin;c:/tools
|
|
1508
|
%rehashdir c:/bin;c:/tools
|
|
1508
|
- Add all executables under c:/bin and c:/tools to alias table, in
|
|
1509
|
- Add all executables under c:/bin and c:/tools to alias table, in
|
|
1509
|
order to make them directly executable from any directory.
|
|
1510
|
order to make them directly executable from any directory.
|
|
1510
|
|
|
1511
|
|
|
1511
|
Without arguments, add all executables in current directory.
|
|
1512
|
Without arguments, add all executables in current directory.
|
|
1512
|
|
|
1513
|
|
|
1513
|
**%rehashx**::
|
|
1514
|
**%rehashx**::
|
|
1514
|
|
|
1515
|
|
|
1515
|
Update the alias table with all executable files in $PATH.
|
|
1516
|
Update the alias table with all executable files in $PATH.
|
|
1516
|
|
|
1517
|
|
|
1517
|
This version explicitly checks that every entry in $PATH is a file
|
|
1518
|
This version explicitly checks that every entry in $PATH is a file
|
|
1518
|
with execute access (os.X_OK), so it is much slower than %rehash.
|
|
1519
|
with execute access (os.X_OK), so it is much slower than %rehash.
|
|
1519
|
|
|
1520
|
|
|
1520
|
Under Windows, it checks executability as a match agains a
|
|
1521
|
Under Windows, it checks executability as a match agains a
|
|
1521
|
'|'-separated string of extensions, stored in the IPython config
|
|
1522
|
'|'-separated string of extensions, stored in the IPython config
|
|
1522
|
variable win_exec_ext. This defaults to 'exe|com|bat'.
|
|
1523
|
variable win_exec_ext. This defaults to 'exe|com|bat'.
|
|
1523
|
|
|
1524
|
|
|
1524
|
This function also resets the root module cache of module completer,
|
|
1525
|
This function also resets the root module cache of module completer,
|
|
1525
|
used on slow filesystems.
|
|
1526
|
used on slow filesystems.
|
|
1526
|
|
|
1527
|
|
|
1527
|
**%rep**::
|
|
1528
|
**%rep**::
|
|
1528
|
|
|
1529
|
|
|
1529
|
Repeat a command, or get command to input line for editing
|
|
1530
|
Repeat a command, or get command to input line for editing
|
|
1530
|
|
|
1531
|
|
|
1531
|
- %rep (no arguments):
|
|
1532
|
- %rep (no arguments):
|
|
1532
|
|
|
1533
|
|
|
1533
|
Place a string version of last computation result (stored in the special '_'
|
|
1534
|
Place a string version of last computation result (stored in the special '_'
|
|
1534
|
variable) to the next input prompt. Allows you to create elaborate command
|
|
1535
|
variable) to the next input prompt. Allows you to create elaborate command
|
|
1535
|
lines without using copy-paste::
|
|
1536
|
lines without using copy-paste::
|
|
1536
|
|
|
1537
|
|
|
1537
|
$ l = ["hei", "vaan"]
|
|
1538
|
$ l = ["hei", "vaan"]
|
|
1538
|
$ "".join(l)
|
|
1539
|
$ "".join(l)
|
|
1539
|
==> heivaan
|
|
1540
|
==> heivaan
|
|
1540
|
$ %rep
|
|
1541
|
$ %rep
|
|
1541
|
$ heivaan_ <== cursor blinking
|
|
1542
|
$ heivaan_ <== cursor blinking
|
|
1542
|
|
|
1543
|
|
|
1543
|
%rep 45
|
|
1544
|
%rep 45
|
|
1544
|
|
|
1545
|
|
|
1545
|
Place history line 45 to next input prompt. Use %hist to find out the
|
|
1546
|
Place history line 45 to next input prompt. Use %hist to find out the
|
|
1546
|
number.
|
|
1547
|
number.
|
|
1547
|
|
|
1548
|
|
|
1548
|
%rep 1-4 6-7 3
|
|
1549
|
%rep 1-4 6-7 3
|
|
1549
|
|
|
1550
|
|
|
1550
|
Repeat the specified lines immediately. Input slice syntax is the same as
|
|
1551
|
Repeat the specified lines immediately. Input slice syntax is the same as
|
|
1551
|
in %macro and %save.
|
|
1552
|
in %macro and %save.
|
|
1552
|
|
|
1553
|
|
|
1553
|
%rep foo
|
|
1554
|
%rep foo
|
|
1554
|
|
|
1555
|
|
|
1555
|
Place the most recent line that has the substring "foo" to next input.
|
|
1556
|
Place the most recent line that has the substring "foo" to next input.
|
|
1556
|
(e.g. 'svn ci -m foobar').
|
|
1557
|
(e.g. 'svn ci -m foobar').
|
|
1557
|
|
|
1558
|
|
|
1558
|
**%reset**::
|
|
1559
|
**%reset**::
|
|
1559
|
|
|
1560
|
|
|
1560
|
Resets the namespace by removing all names defined by the user.
|
|
1561
|
Resets the namespace by removing all names defined by the user.
|
|
1561
|
|
|
1562
|
|
|
1562
|
Input/Output history are left around in case you need them.
|
|
1563
|
Input/Output history are left around in case you need them.
|
|
1563
|
|
|
1564
|
|
|
1564
|
**%run**::
|
|
1565
|
**%run**::
|
|
1565
|
|
|
1566
|
|
|
1566
|
Run the named file inside IPython as a program.
|
|
1567
|
Run the named file inside IPython as a program.
|
|
1567
|
|
|
1568
|
|
|
1568
|
Usage:\
|
|
1569
|
Usage:\
|
|
1569
|
%run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
|
|
1570
|
%run [-n -i -t [-N<N>] -d [-b<N>] -p [profile options]] file [args]
|
|
1570
|
|
|
1571
|
|
|
1571
|
Parameters after the filename are passed as command-line arguments to
|
|
1572
|
Parameters after the filename are passed as command-line arguments to
|
|
1572
|
the program (put in sys.argv). Then, control returns to IPython's
|
|
1573
|
the program (put in sys.argv). Then, control returns to IPython's
|
|
1573
|
prompt.
|
|
1574
|
prompt.
|
|
1574
|
|
|
1575
|
|
|
1575
|
This is similar to running at a system prompt:\
|
|
1576
|
This is similar to running at a system prompt:\
|
|
1576
|
$ python file args\
|
|
1577
|
$ python file args\
|
|
1577
|
but with the advantage of giving you IPython's tracebacks, and of
|
|
1578
|
but with the advantage of giving you IPython's tracebacks, and of
|
|
1578
|
loading all variables into your interactive namespace for further use
|
|
1579
|
loading all variables into your interactive namespace for further use
|
|
1579
|
(unless -p is used, see below).
|
|
1580
|
(unless -p is used, see below).
|
|
1580
|
|
|
1581
|
|
|
1581
|
The file is executed in a namespace initially consisting only of
|
|
1582
|
The file is executed in a namespace initially consisting only of
|
|
1582
|
__name__=='__main__' and sys.argv constructed as indicated. It thus
|
|
1583
|
__name__=='__main__' and sys.argv constructed as indicated. It thus
|
|
1583
|
sees its environment as if it were being run as a stand-alone program
|
|
1584
|
sees its environment as if it were being run as a stand-alone program
|
|
1584
|
(except for sharing global objects such as previously imported
|
|
1585
|
(except for sharing global objects such as previously imported
|
|
1585
|
modules). But after execution, the IPython interactive namespace gets
|
|
1586
|
modules). But after execution, the IPython interactive namespace gets
|
|
1586
|
updated with all variables defined in the program (except for __name__
|
|
1587
|
updated with all variables defined in the program (except for __name__
|
|
1587
|
and sys.argv). This allows for very convenient loading of code for
|
|
1588
|
and sys.argv). This allows for very convenient loading of code for
|
|
1588
|
interactive work, while giving each program a 'clean sheet' to run in.
|
|
1589
|
interactive work, while giving each program a 'clean sheet' to run in.
|
|
1589
|
|
|
1590
|
|
|
1590
|
Options:
|
|
1591
|
Options:
|
|
1591
|
|
|
1592
|
|
|
1592
|
-n: __name__ is NOT set to '__main__', but to the running file's name
|
|
1593
|
-n: __name__ is NOT set to '__main__', but to the running file's name
|
|
1593
|
without extension (as python does under import). This allows running
|
|
1594
|
without extension (as python does under import). This allows running
|
|
1594
|
scripts and reloading the definitions in them without calling code
|
|
1595
|
scripts and reloading the definitions in them without calling code
|
|
1595
|
protected by an ' if __name__ == "__main__" ' clause.
|
|
1596
|
protected by an ' if __name__ == "__main__" ' clause.
|
|
1596
|
|
|
1597
|
|
|
1597
|
-i: run the file in IPython's namespace instead of an empty one. This
|
|
1598
|
-i: run the file in IPython's namespace instead of an empty one. This
|
|
1598
|
is useful if you are experimenting with code written in a text editor
|
|
1599
|
is useful if you are experimenting with code written in a text editor
|
|
1599
|
which depends on variables defined interactively.
|
|
1600
|
which depends on variables defined interactively.
|
|
1600
|
|
|
1601
|
|
|
1601
|
-e: ignore sys.exit() calls or SystemExit exceptions in the script
|
|
1602
|
-e: ignore sys.exit() calls or SystemExit exceptions in the script
|
|
1602
|
being run. This is particularly useful if IPython is being used to
|
|
1603
|
being run. This is particularly useful if IPython is being used to
|
|
1603
|
run unittests, which always exit with a sys.exit() call. In such
|
|
1604
|
run unittests, which always exit with a sys.exit() call. In such
|
|
1604
|
cases you are interested in the output of the test results, not in
|
|
1605
|
cases you are interested in the output of the test results, not in
|
|
1605
|
seeing a traceback of the unittest module.
|
|
1606
|
seeing a traceback of the unittest module.
|
|
1606
|
|
|
1607
|
|
|
1607
|
-t: print timing information at the end of the run. IPython will give
|
|
1608
|
-t: print timing information at the end of the run. IPython will give
|
|
1608
|
you an estimated CPU time consumption for your script, which under
|
|
1609
|
you an estimated CPU time consumption for your script, which under
|
|
1609
|
Unix uses the resource module to avoid the wraparound problems of
|
|
1610
|
Unix uses the resource module to avoid the wraparound problems of
|
|
1610
|
time.clock(). Under Unix, an estimate of time spent on system tasks
|
|
1611
|
time.clock(). Under Unix, an estimate of time spent on system tasks
|
|
1611
|
is also given (for Windows platforms this is reported as 0.0).
|
|
1612
|
is also given (for Windows platforms this is reported as 0.0).
|
|
1612
|
|
|
1613
|
|
|
1613
|
If -t is given, an additional -N<N> option can be given, where <N>
|
|
1614
|
If -t is given, an additional -N<N> option can be given, where <N>
|
|
1614
|
must be an integer indicating how many times you want the script to
|
|
1615
|
must be an integer indicating how many times you want the script to
|
|
1615
|
run. The final timing report will include total and per run results.
|
|
1616
|
run. The final timing report will include total and per run results.
|
|
1616
|
|
|
1617
|
|
|
1617
|
For example (testing the script uniq_stable.py):
|
|
1618
|
For example (testing the script uniq_stable.py):
|
|
1618
|
|
|
1619
|
|
|
1619
|
In [1]: run -t uniq_stable
|
|
1620
|
In [1]: run -t uniq_stable
|
|
1620
|
|
|
1621
|
|
|
1621
|
IPython CPU timings (estimated):\
|
|
1622
|
IPython CPU timings (estimated):\
|
|
1622
|
User : 0.19597 s.\
|
|
1623
|
User : 0.19597 s.\
|
|
1623
|
System: 0.0 s.\
|
|
1624
|
System: 0.0 s.\
|
|
1624
|
|
|
1625
|
|
|
1625
|
In [2]: run -t -N5 uniq_stable
|
|
1626
|
In [2]: run -t -N5 uniq_stable
|
|
1626
|
|
|
1627
|
|
|
1627
|
IPython CPU timings (estimated):\
|
|
1628
|
IPython CPU timings (estimated):\
|
|
1628
|
Total runs performed: 5\
|
|
1629
|
Total runs performed: 5\
|
|
1629
|
Times : Total Per run\
|
|
1630
|
Times : Total Per run\
|
|
1630
|
User : 0.910862 s, 0.1821724 s.\
|
|
1631
|
User : 0.910862 s, 0.1821724 s.\
|
|
1631
|
System: 0.0 s, 0.0 s.
|
|
1632
|
System: 0.0 s, 0.0 s.
|
|
1632
|
|
|
1633
|
|
|
1633
|
-d: run your program under the control of pdb, the Python debugger.
|
|
1634
|
-d: run your program under the control of pdb, the Python debugger.
|
|
1634
|
This allows you to execute your program step by step, watch variables,
|
|
1635
|
This allows you to execute your program step by step, watch variables,
|
|
1635
|
etc. Internally, what IPython does is similar to calling:
|
|
1636
|
etc. Internally, what IPython does is similar to calling:
|
|
1636
|
|
|
1637
|
|
|
1637
|
pdb.run('execfile("YOURFILENAME")')
|
|
1638
|
pdb.run('execfile("YOURFILENAME")')
|
|
1638
|
|
|
1639
|
|
|
1639
|
with a breakpoint set on line 1 of your file. You can change the line
|
|
1640
|
with a breakpoint set on line 1 of your file. You can change the line
|
|
1640
|
number for this automatic breakpoint to be <N> by using the -bN option
|
|
1641
|
number for this automatic breakpoint to be <N> by using the -bN option
|
|
1641
|
(where N must be an integer). For example:
|
|
1642
|
(where N must be an integer). For example:
|
|
1642
|
|
|
1643
|
|
|
1643
|
%run -d -b40 myscript
|
|
1644
|
%run -d -b40 myscript
|
|
1644
|
|
|
1645
|
|
|
1645
|
will set the first breakpoint at line 40 in myscript.py. Note that
|
|
1646
|
will set the first breakpoint at line 40 in myscript.py. Note that
|
|
1646
|
the first breakpoint must be set on a line which actually does
|
|
1647
|
the first breakpoint must be set on a line which actually does
|
|
1647
|
something (not a comment or docstring) for it to stop execution.
|
|
1648
|
something (not a comment or docstring) for it to stop execution.
|
|
1648
|
|
|
1649
|
|
|
1649
|
When the pdb debugger starts, you will see a (Pdb) prompt. You must
|
|
1650
|
When the pdb debugger starts, you will see a (Pdb) prompt. You must
|
|
1650
|
first enter 'c' (without qoutes) to start execution up to the first
|
|
1651
|
first enter 'c' (without qoutes) to start execution up to the first
|
|
1651
|
breakpoint.
|
|
1652
|
breakpoint.
|
|
1652
|
|
|
1653
|
|
|
1653
|
Entering 'help' gives information about the use of the debugger. You
|
|
1654
|
Entering 'help' gives information about the use of the debugger. You
|
|
1654
|
can easily see pdb's full documentation with "import pdb;pdb.help()"
|
|
1655
|
can easily see pdb's full documentation with "import pdb;pdb.help()"
|
|
1655
|
at a prompt.
|
|
1656
|
at a prompt.
|
|
1656
|
|
|
1657
|
|
|
1657
|
-p: run program under the control of the Python profiler module (which
|
|
1658
|
-p: run program under the control of the Python profiler module (which
|
|
1658
|
prints a detailed report of execution times, function calls, etc).
|
|
1659
|
prints a detailed report of execution times, function calls, etc).
|
|
1659
|
|
|
1660
|
|
|
1660
|
You can pass other options after -p which affect the behavior of the
|
|
1661
|
You can pass other options after -p which affect the behavior of the
|
|
1661
|
profiler itself. See the docs for %prun for details.
|
|
1662
|
profiler itself. See the docs for %prun for details.
|
|
1662
|
|
|
1663
|
|
|
1663
|
In this mode, the program's variables do NOT propagate back to the
|
|
1664
|
In this mode, the program's variables do NOT propagate back to the
|
|
1664
|
IPython interactive namespace (because they remain in the namespace
|
|
1665
|
IPython interactive namespace (because they remain in the namespace
|
|
1665
|
where the profiler executes them).
|
|
1666
|
where the profiler executes them).
|
|
1666
|
|
|
1667
|
|
|
1667
|
Internally this triggers a call to %prun, see its documentation for
|
|
1668
|
Internally this triggers a call to %prun, see its documentation for
|
|
1668
|
details on the options available specifically for profiling.
|
|
1669
|
details on the options available specifically for profiling.
|
|
1669
|
|
|
1670
|
|
|
1670
|
There is one special usage for which the text above doesn't apply:
|
|
1671
|
There is one special usage for which the text above doesn't apply:
|
|
1671
|
if the filename ends with .ipy, the file is run as ipython script,
|
|
1672
|
if the filename ends with .ipy, the file is run as ipython script,
|
|
1672
|
just as if the commands were written on IPython prompt.
|
|
1673
|
just as if the commands were written on IPython prompt.
|
|
1673
|
|
|
1674
|
|
|
1674
|
**%runlog**::
|
|
1675
|
**%runlog**::
|
|
1675
|
|
|
1676
|
|
|
1676
|
Run files as logs.
|
|
1677
|
Run files as logs.
|
|
1677
|
|
|
1678
|
|
|
1678
|
Usage:\
|
|
1679
|
Usage:\
|
|
1679
|
%runlog file1 file2 ...
|
|
1680
|
%runlog file1 file2 ...
|
|
1680
|
|
|
1681
|
|
|
1681
|
Run the named files (treating them as log files) in sequence inside
|
|
1682
|
Run the named files (treating them as log files) in sequence inside
|
|
1682
|
the interpreter, and return to the prompt. This is much slower than
|
|
1683
|
the interpreter, and return to the prompt. This is much slower than
|
|
1683
|
%run because each line is executed in a try/except block, but it
|
|
1684
|
%run because each line is executed in a try/except block, but it
|
|
1684
|
allows running files with syntax errors in them.
|
|
1685
|
allows running files with syntax errors in them.
|
|
1685
|
|
|
1686
|
|
|
1686
|
Normally IPython will guess when a file is one of its own logfiles, so
|
|
1687
|
Normally IPython will guess when a file is one of its own logfiles, so
|
|
1687
|
you can typically use %run even for logs. This shorthand allows you to
|
|
1688
|
you can typically use %run even for logs. This shorthand allows you to
|
|
1688
|
force any file to be treated as a log file.
|
|
1689
|
force any file to be treated as a log file.
|
|
1689
|
|
|
1690
|
|
|
1690
|
**%save**::
|
|
1691
|
**%save**::
|
|
1691
|
|
|
1692
|
|
|
1692
|
Save a set of lines to a given filename.
|
|
1693
|
Save a set of lines to a given filename.
|
|
1693
|
|
|
1694
|
|
|
1694
|
Usage:\
|
|
1695
|
Usage:\
|
|
1695
|
%save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
|
|
1696
|
%save [options] filename n1-n2 n3-n4 ... n5 .. n6 ...
|
|
1696
|
|
|
1697
|
|
|
1697
|
Options:
|
|
1698
|
Options:
|
|
1698
|
|
|
1699
|
|
|
1699
|
-r: use 'raw' input. By default, the 'processed' history is used,
|
|
1700
|
-r: use 'raw' input. By default, the 'processed' history is used,
|
|
1700
|
so that magics are loaded in their transformed version to valid
|
|
1701
|
so that magics are loaded in their transformed version to valid
|
|
1701
|
Python. If this option is given, the raw input as typed as the
|
|
1702
|
Python. If this option is given, the raw input as typed as the
|
|
1702
|
command line is used instead.
|
|
1703
|
command line is used instead.
|
|
1703
|
|
|
1704
|
|
|
1704
|
This function uses the same syntax as %macro for line extraction, but
|
|
1705
|
This function uses the same syntax as %macro for line extraction, but
|
|
1705
|
instead of creating a macro it saves the resulting string to the
|
|
1706
|
instead of creating a macro it saves the resulting string to the
|
|
1706
|
filename you specify.
|
|
1707
|
filename you specify.
|
|
1707
|
|
|
1708
|
|
|
1708
|
It adds a '.py' extension to the file if you don't do so yourself, and
|
|
1709
|
It adds a '.py' extension to the file if you don't do so yourself, and
|
|
1709
|
it asks for confirmation before overwriting existing files.
|
|
1710
|
it asks for confirmation before overwriting existing files.
|
|
1710
|
|
|
1711
|
|
|
1711
|
**%sc**::
|
|
1712
|
**%sc**::
|
|
1712
|
|
|
1713
|
|
|
1713
|
Shell capture - execute a shell command and capture its output.
|
|
1714
|
Shell capture - execute a shell command and capture its output.
|
|
1714
|
|
|
1715
|
|
|
1715
|
DEPRECATED. Suboptimal, retained for backwards compatibility.
|
|
1716
|
DEPRECATED. Suboptimal, retained for backwards compatibility.
|
|
1716
|
|
|
1717
|
|
|
1717
|
You should use the form 'var = !command' instead. Example:
|
|
1718
|
You should use the form 'var = !command' instead. Example:
|
|
1718
|
|
|
1719
|
|
|
1719
|
"%sc -l myfiles = ls ~" should now be written as
|
|
1720
|
"%sc -l myfiles = ls ~" should now be written as
|
|
1720
|
|
|
1721
|
|
|
1721
|
"myfiles = !ls ~"
|
|
1722
|
"myfiles = !ls ~"
|
|
1722
|
|
|
1723
|
|
|
1723
|
myfiles.s, myfiles.l and myfiles.n still apply as documented
|
|
1724
|
myfiles.s, myfiles.l and myfiles.n still apply as documented
|
|
1724
|
below.
|
|
1725
|
below.
|
|
1725
|
|
|
1726
|
|
|
1726
|
--
|
|
1727
|
--
|
|
1727
|
%sc [options] varname=command
|
|
1728
|
%sc [options] varname=command
|
|
1728
|
|
|
1729
|
|
|
1729
|
IPython will run the given command using commands.getoutput(), and
|
|
1730
|
IPython will run the given command using commands.getoutput(), and
|
|
1730
|
will then update the user's interactive namespace with a variable
|
|
1731
|
will then update the user's interactive namespace with a variable
|
|
1731
|
called varname, containing the value of the call. Your command can
|
|
1732
|
called varname, containing the value of the call. Your command can
|
|
1732
|
contain shell wildcards, pipes, etc.
|
|
1733
|
contain shell wildcards, pipes, etc.
|
|
1733
|
|
|
1734
|
|
|
1734
|
The '=' sign in the syntax is mandatory, and the variable name you
|
|
1735
|
The '=' sign in the syntax is mandatory, and the variable name you
|
|
1735
|
supply must follow Python's standard conventions for valid names.
|
|
1736
|
supply must follow Python's standard conventions for valid names.
|
|
1736
|
|
|
1737
|
|
|
1737
|
(A special format without variable name exists for internal use)
|
|
1738
|
(A special format without variable name exists for internal use)
|
|
1738
|
|
|
1739
|
|
|
1739
|
Options:
|
|
1740
|
Options:
|
|
1740
|
|
|
1741
|
|
|
1741
|
-l: list output. Split the output on newlines into a list before
|
|
1742
|
-l: list output. Split the output on newlines into a list before
|
|
1742
|
assigning it to the given variable. By default the output is stored
|
|
1743
|
assigning it to the given variable. By default the output is stored
|
|
1743
|
as a single string.
|
|
1744
|
as a single string.
|
|
1744
|
|
|
1745
|
|
|
1745
|
-v: verbose. Print the contents of the variable.
|
|
1746
|
-v: verbose. Print the contents of the variable.
|
|
1746
|
|
|
1747
|
|
|
1747
|
In most cases you should not need to split as a list, because the
|
|
1748
|
In most cases you should not need to split as a list, because the
|
|
1748
|
returned value is a special type of string which can automatically
|
|
1749
|
returned value is a special type of string which can automatically
|
|
1749
|
provide its contents either as a list (split on newlines) or as a
|
|
1750
|
provide its contents either as a list (split on newlines) or as a
|
|
1750
|
space-separated string. These are convenient, respectively, either
|
|
1751
|
space-separated string. These are convenient, respectively, either
|
|
1751
|
for sequential processing or to be passed to a shell command.
|
|
1752
|
for sequential processing or to be passed to a shell command.
|
|
1752
|
|
|
1753
|
|
|
1753
|
For example:
|
|
1754
|
For example:
|
|
1754
|
|
|
1755
|
|
|
1755
|
# Capture into variable a
|
|
1756
|
# Capture into variable a
|
|
1756
|
In [9]: sc a=ls *py
|
|
1757
|
In [9]: sc a=ls *py
|
|
1757
|
|
|
1758
|
|
|
1758
|
# a is a string with embedded newlines
|
|
1759
|
# a is a string with embedded newlines
|
|
1759
|
In [10]: a
|
|
1760
|
In [10]: a
|
|
1760
|
Out[10]: 'setup.py win32_manual_post_install.py'
|
|
1761
|
Out[10]: 'setup.py win32_manual_post_install.py'
|
|
1761
|
|
|
1762
|
|
|
1762
|
# which can be seen as a list:
|
|
1763
|
# which can be seen as a list:
|
|
1763
|
In [11]: a.l
|
|
1764
|
In [11]: a.l
|
|
1764
|
Out[11]: ['setup.py', 'win32_manual_post_install.py']
|
|
1765
|
Out[11]: ['setup.py', 'win32_manual_post_install.py']
|
|
1765
|
|
|
1766
|
|
|
1766
|
# or as a whitespace-separated string:
|
|
1767
|
# or as a whitespace-separated string:
|
|
1767
|
In [12]: a.s
|
|
1768
|
In [12]: a.s
|
|
1768
|
Out[12]: 'setup.py win32_manual_post_install.py'
|
|
1769
|
Out[12]: 'setup.py win32_manual_post_install.py'
|
|
1769
|
|
|
1770
|
|
|
1770
|
# a.s is useful to pass as a single command line:
|
|
1771
|
# a.s is useful to pass as a single command line:
|
|
1771
|
In [13]: !wc -l $a.s
|
|
1772
|
In [13]: !wc -l $a.s
|
|
1772
|
146 setup.py
|
|
1773
|
146 setup.py
|
|
1773
|
130 win32_manual_post_install.py
|
|
1774
|
130 win32_manual_post_install.py
|
|
1774
|
276 total
|
|
1775
|
276 total
|
|
1775
|
|
|
1776
|
|
|
1776
|
# while the list form is useful to loop over:
|
|
1777
|
# while the list form is useful to loop over:
|
|
1777
|
In [14]: for f in a.l:
|
|
1778
|
In [14]: for f in a.l:
|
|
1778
|
....: !wc -l $f
|
|
1779
|
....: !wc -l $f
|
|
1779
|
....:
|
|
1780
|
....:
|
|
1780
|
146 setup.py
|
|
1781
|
146 setup.py
|
|
1781
|
130 win32_manual_post_install.py
|
|
1782
|
130 win32_manual_post_install.py
|
|
1782
|
|
|
1783
|
|
|
1783
|
Similiarly, the lists returned by the -l option are also special, in
|
|
1784
|
Similiarly, the lists returned by the -l option are also special, in
|
|
1784
|
the sense that you can equally invoke the .s attribute on them to
|
|
1785
|
the sense that you can equally invoke the .s attribute on them to
|
|
1785
|
automatically get a whitespace-separated string from their contents:
|
|
1786
|
automatically get a whitespace-separated string from their contents:
|
|
1786
|
|
|
1787
|
|
|
1787
|
In [1]: sc -l b=ls *py
|
|
1788
|
In [1]: sc -l b=ls *py
|
|
1788
|
|
|
1789
|
|
|
1789
|
In [2]: b
|
|
1790
|
In [2]: b
|
|
1790
|
Out[2]: ['setup.py', 'win32_manual_post_install.py']
|
|
1791
|
Out[2]: ['setup.py', 'win32_manual_post_install.py']
|
|
1791
|
|
|
1792
|
|
|
1792
|
In [3]: b.s
|
|
1793
|
In [3]: b.s
|
|
1793
|
Out[3]: 'setup.py win32_manual_post_install.py'
|
|
1794
|
Out[3]: 'setup.py win32_manual_post_install.py'
|
|
1794
|
|
|
1795
|
|
|
1795
|
In summary, both the lists and strings used for ouptut capture have
|
|
1796
|
In summary, both the lists and strings used for ouptut capture have
|
|
1796
|
the following special attributes:
|
|
1797
|
the following special attributes:
|
|
1797
|
|
|
1798
|
|
|
1798
|
.l (or .list) : value as list.
|
|
1799
|
.l (or .list) : value as list.
|
|
1799
|
.n (or .nlstr): value as newline-separated string.
|
|
1800
|
.n (or .nlstr): value as newline-separated string.
|
|
1800
|
.s (or .spstr): value as space-separated string.
|
|
1801
|
.s (or .spstr): value as space-separated string.
|
|
1801
|
|
|
1802
|
|
|
1802
|
**%store**::
|
|
1803
|
**%store**::
|
|
1803
|
|
|
1804
|
|
|
1804
|
Lightweight persistence for python variables.
|
|
1805
|
Lightweight persistence for python variables.
|
|
1805
|
|
|
1806
|
|
|
1806
|
Example:
|
|
1807
|
Example:
|
|
1807
|
|
|
1808
|
|
|
1808
|
ville@badger[~]|1> A = ['hello',10,'world']\
|
|
1809
|
ville@badger[~]|1> A = ['hello',10,'world']\
|
|
1809
|
ville@badger[~]|2> %store A\
|
|
1810
|
ville@badger[~]|2> %store A\
|
|
1810
|
ville@badger[~]|3> Exit
|
|
1811
|
ville@badger[~]|3> Exit
|
|
1811
|
|
|
1812
|
|
|
1812
|
(IPython session is closed and started again...)
|
|
1813
|
(IPython session is closed and started again...)
|
|
1813
|
|
|
1814
|
|
|
1814
|
ville@badger:~$ ipython -p pysh\
|
|
1815
|
ville@badger:~$ ipython -p pysh\
|
|
1815
|
ville@badger[~]|1> print A
|
|
1816
|
ville@badger[~]|1> print A
|
|
1816
|
|
|
1817
|
|
|
1817
|
['hello', 10, 'world']
|
|
1818
|
['hello', 10, 'world']
|
|
1818
|
|
|
1819
|
|
|
1819
|
Usage:
|
|
1820
|
Usage:
|
|
1820
|
|
|
1821
|
|
|
1821
|
%store - Show list of all variables and their current values\
|
|
1822
|
%store - Show list of all variables and their current values\
|
|
1822
|
%store <var> - Store the *current* value of the variable to disk\
|
|
1823
|
%store <var> - Store the *current* value of the variable to disk\
|
|
1823
|
%store -d <var> - Remove the variable and its value from storage\
|
|
1824
|
%store -d <var> - Remove the variable and its value from storage\
|
|
1824
|
%store -z - Remove all variables from storage\
|
|
1825
|
%store -z - Remove all variables from storage\
|
|
1825
|
%store -r - Refresh all variables from store (delete current vals)\
|
|
1826
|
%store -r - Refresh all variables from store (delete current vals)\
|
|
1826
|
%store foo >a.txt - Store value of foo to new file a.txt\
|
|
1827
|
%store foo >a.txt - Store value of foo to new file a.txt\
|
|
1827
|
%store foo >>a.txt - Append value of foo to file a.txt\
|
|
1828
|
%store foo >>a.txt - Append value of foo to file a.txt\
|
|
1828
|
|
|
1829
|
|
|
1829
|
It should be noted that if you change the value of a variable, you
|
|
1830
|
It should be noted that if you change the value of a variable, you
|
|
1830
|
need to %store it again if you want to persist the new value.
|
|
1831
|
need to %store it again if you want to persist the new value.
|
|
1831
|
|
|
1832
|
|
|
1832
|
Note also that the variables will need to be pickleable; most basic
|
|
1833
|
Note also that the variables will need to be pickleable; most basic
|
|
1833
|
python types can be safely %stored.
|
|
1834
|
python types can be safely %stored.
|
|
1834
|
|
|
1835
|
|
|
1835
|
Also aliases can be %store'd across sessions.
|
|
1836
|
Also aliases can be %store'd across sessions.
|
|
1836
|
|
|
1837
|
|
|
1837
|
**%sx**::
|
|
1838
|
**%sx**::
|
|
1838
|
|
|
1839
|
|
|
1839
|
Shell execute - run a shell command and capture its output.
|
|
1840
|
Shell execute - run a shell command and capture its output.
|
|
1840
|
|
|
1841
|
|
|
1841
|
%sx command
|
|
1842
|
%sx command
|
|
1842
|
|
|
1843
|
|
|
1843
|
IPython will run the given command using commands.getoutput(), and
|
|
1844
|
IPython will run the given command using commands.getoutput(), and
|
|
1844
|
return the result formatted as a list (split on '\n'). Since the
|
|
1845
|
return the result formatted as a list (split on '\n'). Since the
|
|
1845
|
output is _returned_, it will be stored in ipython's regular output
|
|
1846
|
output is _returned_, it will be stored in ipython's regular output
|
|
1846
|
cache Out[N] and in the '_N' automatic variables.
|
|
1847
|
cache Out[N] and in the '_N' automatic variables.
|
|
1847
|
|
|
1848
|
|
|
1848
|
Notes:
|
|
1849
|
Notes:
|
|
1849
|
|
|
1850
|
|
|
1850
|
1) If an input line begins with '!!', then %sx is automatically
|
|
1851
|
1) If an input line begins with '!!', then %sx is automatically
|
|
1851
|
invoked. That is, while:
|
|
1852
|
invoked. That is, while:
|
|
1852
|
!ls
|
|
1853
|
!ls
|
|
1853
|
causes ipython to simply issue system('ls'), typing
|
|
1854
|
causes ipython to simply issue system('ls'), typing
|
|
1854
|
!!ls
|
|
1855
|
!!ls
|
|
1855
|
is a shorthand equivalent to:
|
|
1856
|
is a shorthand equivalent to:
|
|
1856
|
%sx ls
|
|
1857
|
%sx ls
|
|
1857
|
|
|
1858
|
|
|
1858
|
2) %sx differs from %sc in that %sx automatically splits into a list,
|
|
1859
|
2) %sx differs from %sc in that %sx automatically splits into a list,
|
|
1859
|
like '%sc -l'. The reason for this is to make it as easy as possible
|
|
1860
|
like '%sc -l'. The reason for this is to make it as easy as possible
|
|
1860
|
to process line-oriented shell output via further python commands.
|
|
1861
|
to process line-oriented shell output via further python commands.
|
|
1861
|
%sc is meant to provide much finer control, but requires more
|
|
1862
|
%sc is meant to provide much finer control, but requires more
|
|
1862
|
typing.
|
|
1863
|
typing.
|
|
1863
|
|
|
1864
|
|
|
1864
|
3) Just like %sc -l, this is a list with special attributes:
|
|
1865
|
3) Just like %sc -l, this is a list with special attributes:
|
|
1865
|
|
|
1866
|
|
|
1866
|
.l (or .list) : value as list.
|
|
1867
|
.l (or .list) : value as list.
|
|
1867
|
.n (or .nlstr): value as newline-separated string.
|
|
1868
|
.n (or .nlstr): value as newline-separated string.
|
|
1868
|
.s (or .spstr): value as whitespace-separated string.
|
|
1869
|
.s (or .spstr): value as whitespace-separated string.
|
|
1869
|
|
|
1870
|
|
|
1870
|
This is very useful when trying to use such lists as arguments to
|
|
1871
|
This is very useful when trying to use such lists as arguments to
|
|
1871
|
system commands.
|
|
1872
|
system commands.
|
|
1872
|
|
|
1873
|
|
|
1873
|
**%system_verbose**::
|
|
1874
|
**%system_verbose**::
|
|
1874
|
|
|
1875
|
|
|
1875
|
Set verbose printing of system calls.
|
|
1876
|
Set verbose printing of system calls.
|
|
1876
|
|
|
1877
|
|
|
1877
|
If called without an argument, act as a toggle
|
|
1878
|
If called without an argument, act as a toggle
|
|
1878
|
|
|
1879
|
|
|
1879
|
**%time**::
|
|
1880
|
**%time**::
|
|
1880
|
|
|
1881
|
|
|
1881
|
Time execution of a Python statement or expression.
|
|
1882
|
Time execution of a Python statement or expression.
|
|
1882
|
|
|
1883
|
|
|
1883
|
The CPU and wall clock times are printed, and the value of the
|
|
1884
|
The CPU and wall clock times are printed, and the value of the
|
|
1884
|
expression (if any) is returned. Note that under Win32, system time
|
|
1885
|
expression (if any) is returned. Note that under Win32, system time
|
|
1885
|
is always reported as 0, since it can not be measured.
|
|
1886
|
is always reported as 0, since it can not be measured.
|
|
1886
|
|
|
1887
|
|
|
1887
|
This function provides very basic timing functionality. In Python
|
|
1888
|
This function provides very basic timing functionality. In Python
|
|
1888
|
2.3, the timeit module offers more control and sophistication, so this
|
|
1889
|
2.3, the timeit module offers more control and sophistication, so this
|
|
1889
|
could be rewritten to use it (patches welcome).
|
|
1890
|
could be rewritten to use it (patches welcome).
|
|
1890
|
|
|
1891
|
|
|
1891
|
Some examples:
|
|
1892
|
Some examples:
|
|
1892
|
|
|
1893
|
|
|
1893
|
In [1]: time 2**128
|
|
1894
|
In [1]: time 2**128
|
|
1894
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1895
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1895
|
Wall time: 0.00
|
|
1896
|
Wall time: 0.00
|
|
1896
|
Out[1]: 340282366920938463463374607431768211456L
|
|
1897
|
Out[1]: 340282366920938463463374607431768211456L
|
|
1897
|
|
|
1898
|
|
|
1898
|
In [2]: n = 1000000
|
|
1899
|
In [2]: n = 1000000
|
|
1899
|
|
|
1900
|
|
|
1900
|
In [3]: time sum(range(n))
|
|
1901
|
In [3]: time sum(range(n))
|
|
1901
|
CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
|
|
1902
|
CPU times: user 1.20 s, sys: 0.05 s, total: 1.25 s
|
|
1902
|
Wall time: 1.37
|
|
1903
|
Wall time: 1.37
|
|
1903
|
Out[3]: 499999500000L
|
|
1904
|
Out[3]: 499999500000L
|
|
1904
|
|
|
1905
|
|
|
1905
|
In [4]: time print 'hello world'
|
|
1906
|
In [4]: time print 'hello world'
|
|
1906
|
hello world
|
|
1907
|
hello world
|
|
1907
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1908
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1908
|
Wall time: 0.00
|
|
1909
|
Wall time: 0.00
|
|
1909
|
|
|
1910
|
|
|
1910
|
Note that the time needed by Python to compile the given expression
|
|
1911
|
Note that the time needed by Python to compile the given expression
|
|
1911
|
will be reported if it is more than 0.1s. In this example, the
|
|
1912
|
will be reported if it is more than 0.1s. In this example, the
|
|
1912
|
actual exponentiation is done by Python at compilation time, so while
|
|
1913
|
actual exponentiation is done by Python at compilation time, so while
|
|
1913
|
the expression can take a noticeable amount of time to compute, that
|
|
1914
|
the expression can take a noticeable amount of time to compute, that
|
|
1914
|
time is purely due to the compilation:
|
|
1915
|
time is purely due to the compilation:
|
|
1915
|
|
|
1916
|
|
|
1916
|
In [5]: time 3**9999;
|
|
1917
|
In [5]: time 3**9999;
|
|
1917
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1918
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1918
|
Wall time: 0.00 s
|
|
1919
|
Wall time: 0.00 s
|
|
1919
|
|
|
1920
|
|
|
1920
|
In [6]: time 3**999999;
|
|
1921
|
In [6]: time 3**999999;
|
|
1921
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1922
|
CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
|
|
1922
|
Wall time: 0.00 s
|
|
1923
|
Wall time: 0.00 s
|
|
1923
|
Compiler : 0.78 s
|
|
1924
|
Compiler : 0.78 s
|
|
1924
|
|
|
1925
|
|
|
1925
|
**%timeit**::
|
|
1926
|
**%timeit**::
|
|
1926
|
|
|
1927
|
|
|
1927
|
Time execution of a Python statement or expression
|
|
1928
|
Time execution of a Python statement or expression
|
|
1928
|
|
|
1929
|
|
|
1929
|
Usage:\
|
|
1930
|
Usage:\
|
|
1930
|
%timeit [-n<N> -r<R> [-t|-c]] statement
|
|
1931
|
%timeit [-n<N> -r<R> [-t|-c]] statement
|
|
1931
|
|
|
1932
|
|
|
1932
|
Time execution of a Python statement or expression using the timeit
|
|
1933
|
Time execution of a Python statement or expression using the timeit
|
|
1933
|
module.
|
|
1934
|
module.
|
|
1934
|
|
|
1935
|
|
|
1935
|
Options:
|
|
1936
|
Options:
|
|
1936
|
-n<N>: execute the given statement <N> times in a loop. If this value
|
|
1937
|
-n<N>: execute the given statement <N> times in a loop. If this value
|
|
1937
|
is not given, a fitting value is chosen.
|
|
1938
|
is not given, a fitting value is chosen.
|
|
1938
|
|
|
1939
|
|
|
1939
|
-r<R>: repeat the loop iteration <R> times and take the best result.
|
|
1940
|
-r<R>: repeat the loop iteration <R> times and take the best result.
|
|
1940
|
Default: 3
|
|
1941
|
Default: 3
|
|
1941
|
|
|
1942
|
|
|
1942
|
-t: use time.time to measure the time, which is the default on Unix.
|
|
1943
|
-t: use time.time to measure the time, which is the default on Unix.
|
|
1943
|
This function measures wall time.
|
|
1944
|
This function measures wall time.
|
|
1944
|
|
|
1945
|
|
|
1945
|
-c: use time.clock to measure the time, which is the default on
|
|
1946
|
-c: use time.clock to measure the time, which is the default on
|
|
1946
|
Windows and measures wall time. On Unix, resource.getrusage is used
|
|
1947
|
Windows and measures wall time. On Unix, resource.getrusage is used
|
|
1947
|
instead and returns the CPU user time.
|
|
1948
|
instead and returns the CPU user time.
|
|
1948
|
|
|
1949
|
|
|
1949
|
-p<P>: use a precision of <P> digits to display the timing result.
|
|
1950
|
-p<P>: use a precision of <P> digits to display the timing result.
|
|
1950
|
Default: 3
|
|
1951
|
Default: 3
|
|
1951
|
|
|
1952
|
|
|
1952
|
|
|
1953
|
|
|
1953
|
Examples:\
|
|
1954
|
Examples:\
|
|
1954
|
In [1]: %timeit pass
|
|
1955
|
In [1]: %timeit pass
|
|
1955
|
10000000 loops, best of 3: 53.3 ns per loop
|
|
1956
|
10000000 loops, best of 3: 53.3 ns per loop
|
|
1956
|
|
|
1957
|
|
|
1957
|
In [2]: u = None
|
|
1958
|
In [2]: u = None
|
|
1958
|
|
|
1959
|
|
|
1959
|
In [3]: %timeit u is None
|
|
1960
|
In [3]: %timeit u is None
|
|
1960
|
10000000 loops, best of 3: 184 ns per loop
|
|
1961
|
10000000 loops, best of 3: 184 ns per loop
|
|
1961
|
|
|
1962
|
|
|
1962
|
In [4]: %timeit -r 4 u == None
|
|
1963
|
In [4]: %timeit -r 4 u == None
|
|
1963
|
1000000 loops, best of 4: 242 ns per loop
|
|
1964
|
1000000 loops, best of 4: 242 ns per loop
|
|
1964
|
|
|
1965
|
|
|
1965
|
In [5]: import time
|
|
1966
|
In [5]: import time
|
|
1966
|
|
|
1967
|
|
|
1967
|
In [6]: %timeit -n1 time.sleep(2)
|
|
1968
|
In [6]: %timeit -n1 time.sleep(2)
|
|
1968
|
1 loops, best of 3: 2 s per loop
|
|
1969
|
1 loops, best of 3: 2 s per loop
|
|
1969
|
|
|
1970
|
|
|
1970
|
|
|
1971
|
|
|
1971
|
The times reported by %timeit will be slightly higher than those
|
|
1972
|
The times reported by %timeit will be slightly higher than those
|
|
1972
|
reported by the timeit.py script when variables are accessed. This is
|
|
1973
|
reported by the timeit.py script when variables are accessed. This is
|
|
1973
|
due to the fact that %timeit executes the statement in the namespace
|
|
1974
|
due to the fact that %timeit executes the statement in the namespace
|
|
1974
|
of the shell, compared with timeit.py, which uses a single setup
|
|
1975
|
of the shell, compared with timeit.py, which uses a single setup
|
|
1975
|
statement to import function or create variables. Generally, the bias
|
|
1976
|
statement to import function or create variables. Generally, the bias
|
|
1976
|
does not matter as long as results from timeit.py are not mixed with
|
|
1977
|
does not matter as long as results from timeit.py are not mixed with
|
|
1977
|
those from %timeit.
|
|
1978
|
those from %timeit.
|
|
1978
|
|
|
1979
|
|
|
1979
|
**%unalias**::
|
|
1980
|
**%unalias**::
|
|
1980
|
|
|
1981
|
|
|
1981
|
Remove an alias
|
|
1982
|
Remove an alias
|
|
1982
|
|
|
1983
|
|
|
1983
|
**%upgrade**::
|
|
1984
|
**%upgrade**::
|
|
1984
|
|
|
1985
|
|
|
1985
|
Upgrade your IPython installation
|
|
1986
|
Upgrade your IPython installation
|
|
1986
|
|
|
1987
|
|
|
1987
|
This will copy the config files that don't yet exist in your
|
|
1988
|
This will copy the config files that don't yet exist in your
|
|
1988
|
ipython dir from the system config dir. Use this after upgrading
|
|
1989
|
ipython dir from the system config dir. Use this after upgrading
|
|
1989
|
IPython if you don't wish to delete your .ipython dir.
|
|
1990
|
IPython if you don't wish to delete your .ipython dir.
|
|
1990
|
|
|
1991
|
|
|
1991
|
Call with -nolegacy to get rid of ipythonrc* files (recommended for
|
|
1992
|
Call with -nolegacy to get rid of ipythonrc* files (recommended for
|
|
1992
|
new users)
|
|
1993
|
new users)
|
|
1993
|
|
|
1994
|
|
|
1994
|
**%which**::
|
|
1995
|
**%which**::
|
|
1995
|
|
|
1996
|
|
|
1996
|
%which <cmd> => search PATH for files matching cmd. Also scans aliases.
|
|
1997
|
%which <cmd> => search PATH for files matching cmd. Also scans aliases.
|
|
1997
|
|
|
1998
|
|
|
1998
|
Traverses PATH and prints all files (not just executables!) that match the
|
|
1999
|
Traverses PATH and prints all files (not just executables!) that match the
|
|
1999
|
pattern on command line. Probably more useful in finding stuff
|
|
2000
|
pattern on command line. Probably more useful in finding stuff
|
|
2000
|
interactively than 'which', which only prints the first matching item.
|
|
2001
|
interactively than 'which', which only prints the first matching item.
|
|
2001
|
|
|
2002
|
|
|
2002
|
Also discovers and expands aliases, so you'll see what will be executed
|
|
2003
|
Also discovers and expands aliases, so you'll see what will be executed
|
|
2003
|
when you call an alias.
|
|
2004
|
when you call an alias.
|
|
2004
|
|
|
2005
|
|
|
2005
|
Example:
|
|
2006
|
Example:
|
|
2006
|
|
|
2007
|
|
|
2007
|
[~]|62> %which d
|
|
2008
|
[~]|62> %which d
|
|
2008
|
d -> ls -F --color=auto
|
|
2009
|
d -> ls -F --color=auto
|
|
2009
|
== c:\cygwin\bin\ls.exe
|
|
2010
|
== c:\cygwin\bin\ls.exe
|
|
2010
|
c:\cygwin\bin\d.exe
|
|
2011
|
c:\cygwin\bin\d.exe
|
|
2011
|
|
|
2012
|
|
|
2012
|
[~]|64> %which diff*
|
|
2013
|
[~]|64> %which diff*
|
|
2013
|
diff3 -> diff3
|
|
2014
|
diff3 -> diff3
|
|
2014
|
== c:\cygwin\bin\diff3.exe
|
|
2015
|
== c:\cygwin\bin\diff3.exe
|
|
2015
|
diff -> diff
|
|
2016
|
diff -> diff
|
|
2016
|
== c:\cygwin\bin\diff.exe
|
|
2017
|
== c:\cygwin\bin\diff.exe
|
|
2017
|
c:\cygwin\bin\diff.exe
|
|
2018
|
c:\cygwin\bin\diff.exe
|
|
2018
|
c:\cygwin\bin\diff3.exe
|
|
2019
|
c:\cygwin\bin\diff3.exe
|
|
2019
|
|
|
2020
|
|
|
2020
|
**%who**::
|
|
2021
|
**%who**::
|
|
2021
|
|
|
2022
|
|
|
2022
|
Print all interactive variables, with some minimal formatting.
|
|
2023
|
Print all interactive variables, with some minimal formatting.
|
|
2023
|
|
|
2024
|
|
|
2024
|
If any arguments are given, only variables whose type matches one of
|
|
2025
|
If any arguments are given, only variables whose type matches one of
|
|
2025
|
these are printed. For example:
|
|
2026
|
these are printed. For example:
|
|
2026
|
|
|
2027
|
|
|
2027
|
%who function str
|
|
2028
|
%who function str
|
|
2028
|
|
|
2029
|
|
|
2029
|
will only list functions and strings, excluding all other types of
|
|
2030
|
will only list functions and strings, excluding all other types of
|
|
2030
|
variables. To find the proper type names, simply use type(var) at a
|
|
2031
|
variables. To find the proper type names, simply use type(var) at a
|
|
2031
|
command line to see how python prints type names. For example:
|
|
2032
|
command line to see how python prints type names. For example:
|
|
2032
|
|
|
2033
|
|
|
2033
|
In [1]: type('hello')\
|
|
2034
|
In [1]: type('hello')\
|
|
2034
|
Out[1]: <type 'str'>
|
|
2035
|
Out[1]: <type 'str'>
|
|
2035
|
|
|
2036
|
|
|
2036
|
indicates that the type name for strings is 'str'.
|
|
2037
|
indicates that the type name for strings is 'str'.
|
|
2037
|
|
|
2038
|
|
|
2038
|
%who always excludes executed names loaded through your configuration
|
|
2039
|
%who always excludes executed names loaded through your configuration
|
|
2039
|
file and things which are internal to IPython.
|
|
2040
|
file and things which are internal to IPython.
|
|
2040
|
|
|
2041
|
|
|
2041
|
This is deliberate, as typically you may load many modules and the
|
|
2042
|
This is deliberate, as typically you may load many modules and the
|
|
2042
|
purpose of %who is to show you only what you've manually defined.
|
|
2043
|
purpose of %who is to show you only what you've manually defined.
|
|
2043
|
|
|
2044
|
|
|
2044
|
**%who_ls**::
|
|
2045
|
**%who_ls**::
|
|
2045
|
|
|
2046
|
|
|
2046
|
Return a sorted list of all interactive variables.
|
|
2047
|
Return a sorted list of all interactive variables.
|
|
2047
|
|
|
2048
|
|
|
2048
|
If arguments are given, only variables of types matching these
|
|
2049
|
If arguments are given, only variables of types matching these
|
|
2049
|
arguments are returned.
|
|
2050
|
arguments are returned.
|
|
2050
|
|
|
2051
|
|
|
2051
|
**%whos**::
|
|
2052
|
**%whos**::
|
|
2052
|
|
|
2053
|
|
|
2053
|
Like %who, but gives some extra information about each variable.
|
|
2054
|
Like %who, but gives some extra information about each variable.
|
|
2054
|
|
|
2055
|
|
|
2055
|
The same type filtering of %who can be applied here.
|
|
2056
|
The same type filtering of %who can be applied here.
|
|
2056
|
|
|
2057
|
|
|
2057
|
For all variables, the type is printed. Additionally it prints:
|
|
2058
|
For all variables, the type is printed. Additionally it prints:
|
|
2058
|
|
|
2059
|
|
|
2059
|
- For {},[],(): their length.
|
|
2060
|
- For {},[],(): their length.
|
|
2060
|
|
|
2061
|
|
|
2061
|
- For numpy and Numeric arrays, a summary with shape, number of
|
|
2062
|
- For numpy and Numeric arrays, a summary with shape, number of
|
|
2062
|
elements, typecode and size in memory.
|
|
2063
|
elements, typecode and size in memory.
|
|
2063
|
|
|
2064
|
|
|
2064
|
- Everything else: a string representation, snipping their middle if
|
|
2065
|
- Everything else: a string representation, snipping their middle if
|
|
2065
|
too long.
|
|
2066
|
too long.
|
|
2066
|
|
|
2067
|
|
|
2067
|
**%xmode**::
|
|
2068
|
**%xmode**::
|
|
2068
|
|
|
2069
|
|
|
2069
|
Switch modes for the exception handlers.
|
|
2070
|
Switch modes for the exception handlers.
|
|
2070
|
|
|
2071
|
|
|
2071
|
Valid modes: Plain, Context and Verbose.
|
|
2072
|
Valid modes: Plain, Context and Verbose.
|
|
2072
|
|
|
2073
|
|
|
2073
|
If called without arguments, acts as a toggle.
|
|
2074
|
If called without arguments, acts as a toggle.
|
|
2074
|
|
|
2075
|
|
|
2075
|
.. magic_end
|
|
2076
|
.. magic_end
|
|
2076
|
|
|
2077
|
|
|
2077
|
Access to the standard Python help
|
|
2078
|
Access to the standard Python help
|
|
2078
|
----------------------------------
|
|
2079
|
----------------------------------
|
|
2079
|
|
|
2080
|
|
|
2080
|
As of Python 2.1, a help system is available with access to object
|
|
2081
|
As of Python 2.1, a help system is available with access to object docstrings
|
|
2081
|
docstrings and the Python manuals. Simply type 'help' (no quotes) to
|
|
2082
|
and the Python manuals. Simply type 'help' (no quotes) to access it. You can
|
|
2082
|
access it. You can also type help(object) to obtain information about a
|
|
2083
|
also type help(object) to obtain information about a given object, and
|
|
2083
|
given object, and help('keyword') for information on a keyword. As noted
|
|
2084
|
help('keyword') for information on a keyword. As noted :ref:`here
|
|
2084
|
in sec. `accessing help`_, you need to properly configure
|
|
2085
|
<accessing_help>`, you need to properly configure your environment variable
|
|
2085
|
your environment variable PYTHONDOCS for this feature to work correctly.
|
|
2086
|
PYTHONDOCS for this feature to work correctly.
|
|
2086
|
|
|
2087
|
|
|
|
|
|
2088
|
.. _dynamic_object_info:
|
|
2087
|
|
|
2089
|
|
|
2088
|
Dynamic object information
|
|
2090
|
Dynamic object information
|
|
2089
|
--------------------------
|
|
2091
|
--------------------------
|
|
2090
|
|
|
2092
|
|
|
2091
|
Typing ?word or word? prints detailed information about an object. If
|
|
2093
|
Typing ?word or word? prints detailed information about an object. If
|
|
2092
|
certain strings in the object are too long (docstrings, code, etc.) they
|
|
2094
|
certain strings in the object are too long (docstrings, code, etc.) they
|
|
2093
|
get snipped in the center for brevity. This system gives access variable
|
|
2095
|
get snipped in the center for brevity. This system gives access variable
|
|
2094
|
types and values, full source code for any object (if available),
|
|
2096
|
types and values, full source code for any object (if available),
|
|
2095
|
function prototypes and other useful information.
|
|
2097
|
function prototypes and other useful information.
|
|
2096
|
|
|
2098
|
|
|
2097
|
Typing ??word or word?? gives access to the full information without
|
|
2099
|
Typing ??word or word?? gives access to the full information without
|
|
2098
|
snipping long strings. Long strings are sent to the screen through the
|
|
2100
|
snipping long strings. Long strings are sent to the screen through the
|
|
2099
|
less pager if longer than the screen and printed otherwise. On systems
|
|
2101
|
less pager if longer than the screen and printed otherwise. On systems
|
|
2100
|
lacking the less command, IPython uses a very basic internal pager.
|
|
2102
|
lacking the less command, IPython uses a very basic internal pager.
|
|
2101
|
|
|
2103
|
|
|
2102
|
The following magic functions are particularly useful for gathering
|
|
2104
|
The following magic functions are particularly useful for gathering
|
|
2103
|
information about your working environment. You can get more details by
|
|
2105
|
information about your working environment. You can get more details by
|
|
2104
|
typing %magic or querying them individually (use %function_name? with or
|
|
2106
|
typing %magic or querying them individually (use %function_name? with or
|
|
2105
|
without the %), this is just a summary:
|
|
2107
|
without the %), this is just a summary:
|
|
2106
|
|
|
2108
|
|
|
2107
|
* **%pdoc <object>**: Print (or run through a pager if too long) the
|
|
2109
|
* **%pdoc <object>**: Print (or run through a pager if too long) the
|
|
2108
|
docstring for an object. If the given object is a class, it will
|
|
2110
|
docstring for an object. If the given object is a class, it will
|
|
2109
|
print both the class and the constructor docstrings.
|
|
2111
|
print both the class and the constructor docstrings.
|
|
2110
|
* **%pdef <object>**: Print the definition header for any callable
|
|
2112
|
* **%pdef <object>**: Print the definition header for any callable
|
|
2111
|
object. If the object is a class, print the constructor information.
|
|
2113
|
object. If the object is a class, print the constructor information.
|
|
2112
|
* **%psource <object>**: Print (or run through a pager if too long)
|
|
2114
|
* **%psource <object>**: Print (or run through a pager if too long)
|
|
2113
|
the source code for an object.
|
|
2115
|
the source code for an object.
|
|
2114
|
* **%pfile <object>**: Show the entire source file where an object was
|
|
2116
|
* **%pfile <object>**: Show the entire source file where an object was
|
|
2115
|
defined via a pager, opening it at the line where the object
|
|
2117
|
defined via a pager, opening it at the line where the object
|
|
2116
|
definition begins.
|
|
2118
|
definition begins.
|
|
2117
|
* **%who/%whos**: These functions give information about identifiers
|
|
2119
|
* **%who/%whos**: These functions give information about identifiers
|
|
2118
|
you have defined interactively (not things you loaded or defined
|
|
2120
|
you have defined interactively (not things you loaded or defined
|
|
2119
|
in your configuration files). %who just prints a list of
|
|
2121
|
in your configuration files). %who just prints a list of
|
|
2120
|
identifiers and %whos prints a table with some basic details about
|
|
2122
|
identifiers and %whos prints a table with some basic details about
|
|
2121
|
each identifier.
|
|
2123
|
each identifier.
|
|
2122
|
|
|
2124
|
|
|
2123
|
Note that the dynamic object information functions (?/??, %pdoc, %pfile,
|
|
2125
|
Note that the dynamic object information functions (?/??, %pdoc, %pfile,
|
|
2124
|
%pdef, %psource) give you access to documentation even on things which
|
|
2126
|
%pdef, %psource) give you access to documentation even on things which
|
|
2125
|
are not really defined as separate identifiers. Try for example typing
|
|
2127
|
are not really defined as separate identifiers. Try for example typing
|
|
2126
|
{}.get? or after doing import os, type os.path.abspath??.
|
|
2128
|
{}.get? or after doing import os, type os.path.abspath??.
|
|
2127
|
|
|
2129
|
|
|
2128
|
|
|
2130
|
|
|
2129
|
.. _Readline:
|
|
2131
|
.. _readline:
|
|
2130
|
|
|
2132
|
|
|
2131
|
Readline-based features
|
|
2133
|
Readline-based features
|
|
2132
|
-----------------------
|
|
2134
|
-----------------------
|
|
2133
|
|
|
2135
|
|
|
2134
|
These features require the GNU readline library, so they won't work if
|
|
2136
|
These features require the GNU readline library, so they won't work if
|
|
2135
|
your Python installation lacks readline support. We will first describe
|
|
2137
|
your Python installation lacks readline support. We will first describe
|
|
2136
|
the default behavior IPython uses, and then how to change it to suit
|
|
2138
|
the default behavior IPython uses, and then how to change it to suit
|
|
2137
|
your preferences.
|
|
2139
|
your preferences.
|
|
2138
|
|
|
2140
|
|
|
2139
|
|
|
2141
|
|
|
2140
|
Command line completion
|
|
2142
|
Command line completion
|
|
2141
|
+++++++++++++++++++++++
|
|
2143
|
+++++++++++++++++++++++
|
|
2142
|
|
|
2144
|
|
|
2143
|
At any time, hitting TAB will complete any available python commands or
|
|
2145
|
At any time, hitting TAB will complete any available python commands or
|
|
2144
|
variable names, and show you a list of the possible completions if
|
|
2146
|
variable names, and show you a list of the possible completions if
|
|
2145
|
there's no unambiguous one. It will also complete filenames in the
|
|
2147
|
there's no unambiguous one. It will also complete filenames in the
|
|
2146
|
current directory if no python names match what you've typed so far.
|
|
2148
|
current directory if no python names match what you've typed so far.
|
|
2147
|
|
|
2149
|
|
|
2148
|
|
|
2150
|
|
|
2149
|
Search command history
|
|
2151
|
Search command history
|
|
2150
|
++++++++++++++++++++++
|
|
2152
|
++++++++++++++++++++++
|
|
2151
|
|
|
2153
|
|
|
2152
|
IPython provides two ways for searching through previous input and thus
|
|
2154
|
IPython provides two ways for searching through previous input and thus
|
|
2153
|
reduce the need for repetitive typing:
|
|
2155
|
reduce the need for repetitive typing:
|
|
2154
|
|
|
2156
|
|
|
2155
|
1. Start typing, and then use Ctrl-p (previous,up) and Ctrl-n
|
|
2157
|
1. Start typing, and then use Ctrl-p (previous,up) and Ctrl-n
|
|
2156
|
(next,down) to search through only the history items that match
|
|
2158
|
(next,down) to search through only the history items that match
|
|
2157
|
what you've typed so far. If you use Ctrl-p/Ctrl-n at a blank
|
|
2159
|
what you've typed so far. If you use Ctrl-p/Ctrl-n at a blank
|
|
2158
|
prompt, they just behave like normal arrow keys.
|
|
2160
|
prompt, they just behave like normal arrow keys.
|
|
2159
|
2. Hit Ctrl-r: opens a search prompt. Begin typing and the system
|
|
2161
|
2. Hit Ctrl-r: opens a search prompt. Begin typing and the system
|
|
2160
|
searches your history for lines that contain what you've typed so
|
|
2162
|
searches your history for lines that contain what you've typed so
|
|
2161
|
far, completing as much as it can.
|
|
2163
|
far, completing as much as it can.
|
|
2162
|
|
|
2164
|
|
|
2163
|
|
|
2165
|
|
|
2164
|
Persistent command history across sessions
|
|
2166
|
Persistent command history across sessions
|
|
2165
|
++++++++++++++++++++++++++++++++++++++++++
|
|
2167
|
++++++++++++++++++++++++++++++++++++++++++
|
|
2166
|
|
|
2168
|
|
|
2167
|
IPython will save your input history when it leaves and reload it next
|
|
2169
|
IPython will save your input history when it leaves and reload it next
|
|
2168
|
time you restart it. By default, the history file is named
|
|
2170
|
time you restart it. By default, the history file is named
|
|
2169
|
$IPYTHONDIR/history, but if you've loaded a named profile,
|
|
2171
|
$IPYTHONDIR/history, but if you've loaded a named profile,
|
|
2170
|
'-PROFILE_NAME' is appended to the name. This allows you to keep
|
|
2172
|
'-PROFILE_NAME' is appended to the name. This allows you to keep
|
|
2171
|
separate histories related to various tasks: commands related to
|
|
2173
|
separate histories related to various tasks: commands related to
|
|
2172
|
numerical work will not be clobbered by a system shell history, for
|
|
2174
|
numerical work will not be clobbered by a system shell history, for
|
|
2173
|
example.
|
|
2175
|
example.
|
|
2174
|
|
|
2176
|
|
|
2175
|
|
|
2177
|
|
|
2176
|
Autoindent
|
|
2178
|
Autoindent
|
|
2177
|
++++++++++
|
|
2179
|
++++++++++
|
|
2178
|
|
|
2180
|
|
|
2179
|
IPython can recognize lines ending in ':' and indent the next line,
|
|
2181
|
IPython can recognize lines ending in ':' and indent the next line,
|
|
2180
|
while also un-indenting automatically after 'raise' or 'return'.
|
|
2182
|
while also un-indenting automatically after 'raise' or 'return'.
|
|
2181
|
|
|
2183
|
|
|
2182
|
This feature uses the readline library, so it will honor your ~/.inputrc
|
|
2184
|
This feature uses the readline library, so it will honor your ~/.inputrc
|
|
2183
|
configuration (or whatever file your INPUTRC variable points to). Adding
|
|
2185
|
configuration (or whatever file your INPUTRC variable points to). Adding
|
|
2184
|
the following lines to your .inputrc file can make indenting/unindenting
|
|
2186
|
the following lines to your .inputrc file can make indenting/unindenting
|
|
2185
|
more convenient (M-i indents, M-u unindents)::
|
|
2187
|
more convenient (M-i indents, M-u unindents)::
|
|
2186
|
|
|
2188
|
|
|
2187
|
$if Python
|
|
2189
|
$if Python
|
|
2188
|
"\M-i": " "
|
|
2190
|
"\M-i": " "
|
|
2189
|
"\M-u": "\d\d\d\d"
|
|
2191
|
"\M-u": "\d\d\d\d"
|
|
2190
|
$endif
|
|
2192
|
$endif
|
|
2191
|
|
|
2193
|
|
|
2192
|
Note that there are 4 spaces between the quote marks after "M-i" above.
|
|
2194
|
Note that there are 4 spaces between the quote marks after "M-i" above.
|
|
2193
|
|
|
2195
|
|
|
2194
|
Warning: this feature is ON by default, but it can cause problems with
|
|
2196
|
Warning: this feature is ON by default, but it can cause problems with
|
|
2195
|
the pasting of multi-line indented code (the pasted code gets
|
|
2197
|
the pasting of multi-line indented code (the pasted code gets
|
|
2196
|
re-indented on each line). A magic function %autoindent allows you to
|
|
2198
|
re-indented on each line). A magic function %autoindent allows you to
|
|
2197
|
toggle it on/off at runtime. You can also disable it permanently on in
|
|
2199
|
toggle it on/off at runtime. You can also disable it permanently on in
|
|
2198
|
your ipythonrc file (set autoindent 0).
|
|
2200
|
your ipythonrc file (set autoindent 0).
|
|
2199
|
|
|
2201
|
|
|
2200
|
|
|
2202
|
|
|
2201
|
Customizing readline behavior
|
|
2203
|
Customizing readline behavior
|
|
2202
|
+++++++++++++++++++++++++++++
|
|
2204
|
+++++++++++++++++++++++++++++
|
|
2203
|
|
|
2205
|
|
|
2204
|
All these features are based on the GNU readline library, which has an
|
|
2206
|
All these features are based on the GNU readline library, which has an
|
|
2205
|
extremely customizable interface. Normally, readline is configured via a
|
|
2207
|
extremely customizable interface. Normally, readline is configured via a
|
|
2206
|
file which defines the behavior of the library; the details of the
|
|
2208
|
file which defines the behavior of the library; the details of the
|
|
2207
|
syntax for this can be found in the readline documentation available
|
|
2209
|
syntax for this can be found in the readline documentation available
|
|
2208
|
with your system or on the Internet. IPython doesn't read this file (if
|
|
2210
|
with your system or on the Internet. IPython doesn't read this file (if
|
|
2209
|
it exists) directly, but it does support passing to readline valid
|
|
2211
|
it exists) directly, but it does support passing to readline valid
|
|
2210
|
options via a simple interface. In brief, you can customize readline by
|
|
2212
|
options via a simple interface. In brief, you can customize readline by
|
|
2211
|
setting the following options in your ipythonrc configuration file (note
|
|
2213
|
setting the following options in your ipythonrc configuration file (note
|
|
2212
|
that these options can not be specified at the command line):
|
|
2214
|
that these options can not be specified at the command line):
|
|
2213
|
|
|
2215
|
|
|
2214
|
* **readline_parse_and_bind**: this option can appear as many times as
|
|
2216
|
* **readline_parse_and_bind**: this option can appear as many times as
|
|
2215
|
you want, each time defining a string to be executed via a
|
|
2217
|
you want, each time defining a string to be executed via a
|
|
2216
|
readline.parse_and_bind() command. The syntax for valid commands
|
|
2218
|
readline.parse_and_bind() command. The syntax for valid commands
|
|
2217
|
of this kind can be found by reading the documentation for the GNU
|
|
2219
|
of this kind can be found by reading the documentation for the GNU
|
|
2218
|
readline library, as these commands are of the kind which readline
|
|
2220
|
readline library, as these commands are of the kind which readline
|
|
2219
|
accepts in its configuration file.
|
|
2221
|
accepts in its configuration file.
|
|
2220
|
* **readline_remove_delims**: a string of characters to be removed
|
|
2222
|
* **readline_remove_delims**: a string of characters to be removed
|
|
2221
|
from the default word-delimiters list used by readline, so that
|
|
2223
|
from the default word-delimiters list used by readline, so that
|
|
2222
|
completions may be performed on strings which contain them. Do not
|
|
2224
|
completions may be performed on strings which contain them. Do not
|
|
2223
|
change the default value unless you know what you're doing.
|
|
2225
|
change the default value unless you know what you're doing.
|
|
2224
|
* **readline_omit__names**: when tab-completion is enabled, hitting
|
|
2226
|
* **readline_omit__names**: when tab-completion is enabled, hitting
|
|
2225
|
<tab> after a '.' in a name will complete all attributes of an
|
|
2227
|
<tab> after a '.' in a name will complete all attributes of an
|
|
2226
|
object, including all the special methods whose names include
|
|
2228
|
object, including all the special methods whose names include
|
|
2227
|
double underscores (like __getitem__ or __class__). If you'd
|
|
2229
|
double underscores (like __getitem__ or __class__). If you'd
|
|
2228
|
rather not see these names by default, you can set this option to
|
|
2230
|
rather not see these names by default, you can set this option to
|
|
2229
|
1. Note that even when this option is set, you can still see those
|
|
2231
|
1. Note that even when this option is set, you can still see those
|
|
2230
|
names by explicitly typing a _ after the period and hitting <tab>:
|
|
2232
|
names by explicitly typing a _ after the period and hitting <tab>:
|
|
2231
|
'name._<tab>' will always complete attribute names starting with '_'.
|
|
2233
|
'name._<tab>' will always complete attribute names starting with '_'.
|
|
2232
|
|
|
2234
|
|
|
2233
|
This option is off by default so that new users see all
|
|
2235
|
This option is off by default so that new users see all
|
|
2234
|
attributes of any objects they are dealing with.
|
|
2236
|
attributes of any objects they are dealing with.
|
|
2235
|
|
|
2237
|
|
|
2236
|
You will find the default values along with a corresponding detailed
|
|
2238
|
You will find the default values along with a corresponding detailed
|
|
2237
|
explanation in your ipythonrc file.
|
|
2239
|
explanation in your ipythonrc file.
|
|
2238
|
|
|
2240
|
|
|
2239
|
|
|
2241
|
|
|
2240
|
Session logging and restoring
|
|
2242
|
Session logging and restoring
|
|
2241
|
-----------------------------
|
|
2243
|
-----------------------------
|
|
2242
|
|
|
2244
|
|
|
2243
|
You can log all input from a session either by starting IPython with
|
|
2245
|
You can log all input from a session either by starting IPython with the
|
|
2244
|
the command line switches -log or -logfile (see sec. `command line
|
|
2246
|
command line switches -log or -logfile (see :ref:`here <command_line_options>`)
|
|
2245
|
options`_) or by activating the logging at any moment with the magic
|
|
2247
|
or by activating the logging at any moment with the magic function %logstart.
|
|
2246
|
function %logstart.
|
|
|
|
|
2247
|
|
|
2248
|
|
|
2248
|
Log files can later be reloaded with the -logplay option and IPython
|
|
2249
|
Log files can later be reloaded with the -logplay option and IPython
|
|
2249
|
will attempt to 'replay' the log by executing all the lines in it, thus
|
|
2250
|
will attempt to 'replay' the log by executing all the lines in it, thus
|
|
2250
|
restoring the state of a previous session. This feature is not quite
|
|
2251
|
restoring the state of a previous session. This feature is not quite
|
|
2251
|
perfect, but can still be useful in many cases.
|
|
2252
|
perfect, but can still be useful in many cases.
|
|
2252
|
|
|
2253
|
|
|
2253
|
The log files can also be used as a way to have a permanent record of
|
|
2254
|
The log files can also be used as a way to have a permanent record of
|
|
2254
|
any code you wrote while experimenting. Log files are regular text files
|
|
2255
|
any code you wrote while experimenting. Log files are regular text files
|
|
2255
|
which you can later open in your favorite text editor to extract code or
|
|
2256
|
which you can later open in your favorite text editor to extract code or
|
|
2256
|
to 'clean them up' before using them to replay a session.
|
|
2257
|
to 'clean them up' before using them to replay a session.
|
|
2257
|
|
|
2258
|
|
|
2258
|
The %logstart function for activating logging in mid-session is used as
|
|
2259
|
The %logstart function for activating logging in mid-session is used as
|
|
2259
|
follows:
|
|
2260
|
follows:
|
|
2260
|
|
|
2261
|
|
|
2261
|
%logstart [log_name [log_mode]]
|
|
2262
|
%logstart [log_name [log_mode]]
|
|
2262
|
|
|
2263
|
|
|
2263
|
If no name is given, it defaults to a file named 'log' in your
|
|
2264
|
If no name is given, it defaults to a file named 'log' in your
|
|
2264
|
IPYTHONDIR directory, in 'rotate' mode (see below).
|
|
2265
|
IPYTHONDIR directory, in 'rotate' mode (see below).
|
|
2265
|
|
|
2266
|
|
|
2266
|
'%logstart name' saves to file 'name' in 'backup' mode. It saves your
|
|
2267
|
'%logstart name' saves to file 'name' in 'backup' mode. It saves your
|
|
2267
|
history up to that point and then continues logging.
|
|
2268
|
history up to that point and then continues logging.
|
|
2268
|
|
|
2269
|
|
|
2269
|
%logstart takes a second optional parameter: logging mode. This can be
|
|
2270
|
%logstart takes a second optional parameter: logging mode. This can be
|
|
2270
|
one of (note that the modes are given unquoted):
|
|
2271
|
one of (note that the modes are given unquoted):
|
|
2271
|
|
|
2272
|
|
|
2272
|
* [over:] overwrite existing log_name.
|
|
2273
|
* [over:] overwrite existing log_name.
|
|
2273
|
* [backup:] rename (if exists) to log_name~ and start log_name.
|
|
2274
|
* [backup:] rename (if exists) to log_name~ and start log_name.
|
|
2274
|
* [append:] well, that says it.
|
|
2275
|
* [append:] well, that says it.
|
|
2275
|
* [rotate:] create rotating logs log_name.1~, log_name.2~, etc.
|
|
2276
|
* [rotate:] create rotating logs log_name.1~, log_name.2~, etc.
|
|
2276
|
|
|
2277
|
|
|
2277
|
The %logoff and %logon functions allow you to temporarily stop and
|
|
2278
|
The %logoff and %logon functions allow you to temporarily stop and
|
|
2278
|
resume logging to a file which had previously been started with
|
|
2279
|
resume logging to a file which had previously been started with
|
|
2279
|
%logstart. They will fail (with an explanation) if you try to use them
|
|
2280
|
%logstart. They will fail (with an explanation) if you try to use them
|
|
2280
|
before logging has been started.
|
|
2281
|
before logging has been started.
|
|
2281
|
|
|
2282
|
|
|
|
|
|
2283
|
.. _system_shell_access:
|
|
|
|
|
2284
|
|
|
2282
|
System shell access
|
|
2285
|
System shell access
|
|
2283
|
-------------------
|
|
2286
|
-------------------
|
|
2284
|
|
|
2287
|
|
|
2285
|
Any input line beginning with a ! character is passed verbatim (minus
|
|
2288
|
Any input line beginning with a ! character is passed verbatim (minus
|
|
2286
|
the !, of course) to the underlying operating system. For example,
|
|
2289
|
the !, of course) to the underlying operating system. For example,
|
|
2287
|
typing !ls will run 'ls' in the current directory.
|
|
2290
|
typing !ls will run 'ls' in the current directory.
|
|
2288
|
|
|
2291
|
|
|
2289
|
Manual capture of command output
|
|
2292
|
Manual capture of command output
|
|
2290
|
--------------------------------
|
|
2293
|
--------------------------------
|
|
2291
|
|
|
2294
|
|
|
2292
|
If the input line begins with two exclamation marks, !!, the command is
|
|
2295
|
If the input line begins with two exclamation marks, !!, the command is
|
|
2293
|
executed but its output is captured and returned as a python list, split
|
|
2296
|
executed but its output is captured and returned as a python list, split
|
|
2294
|
on newlines. Any output sent by the subprocess to standard error is
|
|
2297
|
on newlines. Any output sent by the subprocess to standard error is
|
|
2295
|
printed separately, so that the resulting list only captures standard
|
|
2298
|
printed separately, so that the resulting list only captures standard
|
|
2296
|
output. The !! syntax is a shorthand for the %sx magic command.
|
|
2299
|
output. The !! syntax is a shorthand for the %sx magic command.
|
|
2297
|
|
|
2300
|
|
|
2298
|
Finally, the %sc magic (short for 'shell capture') is similar to %sx,
|
|
2301
|
Finally, the %sc magic (short for 'shell capture') is similar to %sx,
|
|
2299
|
but allowing more fine-grained control of the capture details, and
|
|
2302
|
but allowing more fine-grained control of the capture details, and
|
|
2300
|
storing the result directly into a named variable. The direct use of
|
|
2303
|
storing the result directly into a named variable. The direct use of
|
|
2301
|
%sc is now deprecated, and you should ise the ``var = !cmd`` syntax
|
|
2304
|
%sc is now deprecated, and you should ise the ``var = !cmd`` syntax
|
|
2302
|
instead.
|
|
2305
|
instead.
|
|
2303
|
|
|
2306
|
|
|
2304
|
IPython also allows you to expand the value of python variables when
|
|
2307
|
IPython also allows you to expand the value of python variables when
|
|
2305
|
making system calls. Any python variable or expression which you prepend
|
|
2308
|
making system calls. Any python variable or expression which you prepend
|
|
2306
|
with $ will get expanded before the system call is made::
|
|
2309
|
with $ will get expanded before the system call is made::
|
|
2307
|
|
|
2310
|
|
|
2308
|
In [1]: pyvar='Hello world'
|
|
2311
|
In [1]: pyvar='Hello world'
|
|
2309
|
In [2]: !echo "A python variable: $pyvar"
|
|
2312
|
In [2]: !echo "A python variable: $pyvar"
|
|
2310
|
A python variable: Hello world
|
|
2313
|
A python variable: Hello world
|
|
2311
|
|
|
2314
|
|
|
2312
|
If you want the shell to actually see a literal $, you need to type it
|
|
2315
|
If you want the shell to actually see a literal $, you need to type it
|
|
2313
|
twice::
|
|
2316
|
twice::
|
|
2314
|
|
|
2317
|
|
|
2315
|
In [3]: !echo "A system variable: $$HOME"
|
|
2318
|
In [3]: !echo "A system variable: $$HOME"
|
|
2316
|
A system variable: /home/fperez
|
|
2319
|
A system variable: /home/fperez
|
|
2317
|
|
|
2320
|
|
|
2318
|
You can pass arbitrary expressions, though you'll need to delimit them
|
|
2321
|
You can pass arbitrary expressions, though you'll need to delimit them
|
|
2319
|
with {} if there is ambiguity as to the extent of the expression::
|
|
2322
|
with {} if there is ambiguity as to the extent of the expression::
|
|
2320
|
|
|
2323
|
|
|
2321
|
In [5]: x=10
|
|
2324
|
In [5]: x=10
|
|
2322
|
In [6]: y=20
|
|
2325
|
In [6]: y=20
|
|
2323
|
In [13]: !echo $x+y
|
|
2326
|
In [13]: !echo $x+y
|
|
2324
|
10+y
|
|
2327
|
10+y
|
|
2325
|
In [7]: !echo ${x+y}
|
|
2328
|
In [7]: !echo ${x+y}
|
|
2326
|
30
|
|
2329
|
30
|
|
2327
|
|
|
2330
|
|
|
2328
|
Even object attributes can be expanded::
|
|
2331
|
Even object attributes can be expanded::
|
|
2329
|
|
|
2332
|
|
|
2330
|
In [12]: !echo $sys.argv
|
|
2333
|
In [12]: !echo $sys.argv
|
|
2331
|
[/home/fperez/usr/bin/ipython]
|
|
2334
|
[/home/fperez/usr/bin/ipython]
|
|
2332
|
|
|
2335
|
|
|
2333
|
|
|
2336
|
|
|
2334
|
System command aliases
|
|
2337
|
System command aliases
|
|
2335
|
----------------------
|
|
2338
|
----------------------
|
|
2336
|
|
|
2339
|
|
|
2337
|
The %alias magic function and the alias option in the ipythonrc
|
|
2340
|
The %alias magic function and the alias option in the ipythonrc
|
|
2338
|
configuration file allow you to define magic functions which are in fact
|
|
2341
|
configuration file allow you to define magic functions which are in fact
|
|
2339
|
system shell commands. These aliases can have parameters.
|
|
2342
|
system shell commands. These aliases can have parameters.
|
|
2340
|
|
|
2343
|
|
|
2341
|
'%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
|
|
2344
|
'%alias alias_name cmd' defines 'alias_name' as an alias for 'cmd'
|
|
2342
|
|
|
2345
|
|
|
2343
|
Then, typing '%alias_name params' will execute the system command 'cmd
|
|
2346
|
Then, typing '%alias_name params' will execute the system command 'cmd
|
|
2344
|
params' (from your underlying operating system).
|
|
2347
|
params' (from your underlying operating system).
|
|
2345
|
|
|
2348
|
|
|
2346
|
You can also define aliases with parameters using %s specifiers (one per
|
|
2349
|
You can also define aliases with parameters using %s specifiers (one per
|
|
2347
|
parameter). The following example defines the %parts function as an
|
|
2350
|
parameter). The following example defines the %parts function as an
|
|
2348
|
alias to the command 'echo first %s second %s' where each %s will be
|
|
2351
|
alias to the command 'echo first %s second %s' where each %s will be
|
|
2349
|
replaced by a positional parameter to the call to %parts::
|
|
2352
|
replaced by a positional parameter to the call to %parts::
|
|
2350
|
|
|
2353
|
|
|
2351
|
In [1]: alias parts echo first %s second %s
|
|
2354
|
In [1]: alias parts echo first %s second %s
|
|
2352
|
In [2]: %parts A B
|
|
2355
|
In [2]: %parts A B
|
|
2353
|
first A second B
|
|
2356
|
first A second B
|
|
2354
|
In [3]: %parts A
|
|
2357
|
In [3]: %parts A
|
|
2355
|
Incorrect number of arguments: 2 expected.
|
|
2358
|
Incorrect number of arguments: 2 expected.
|
|
2356
|
parts is an alias to: 'echo first %s second %s'
|
|
2359
|
parts is an alias to: 'echo first %s second %s'
|
|
2357
|
|
|
2360
|
|
|
2358
|
If called with no parameters, %alias prints the table of currently
|
|
2361
|
If called with no parameters, %alias prints the table of currently
|
|
2359
|
defined aliases.
|
|
2362
|
defined aliases.
|
|
2360
|
|
|
2363
|
|
|
2361
|
The %rehash/rehashx magics allow you to load your entire $PATH as
|
|
2364
|
The %rehash/rehashx magics allow you to load your entire $PATH as
|
|
2362
|
ipython aliases. See their respective docstrings (or sec. 6.2
|
|
2365
|
ipython aliases. See their respective docstrings (or sec. 6.2
|
|
2363
|
<#sec:magic> for further details).
|
|
2366
|
<#sec:magic> for further details).
|
|
2364
|
|
|
2367
|
|
|
2365
|
|
|
2368
|
|
|
2366
|
.. _dreload:
|
|
2369
|
.. _dreload:
|
|
2367
|
|
|
2370
|
|
|
2368
|
Recursive reload
|
|
2371
|
Recursive reload
|
|
2369
|
----------------
|
|
2372
|
----------------
|
|
2370
|
|
|
2373
|
|
|
2371
|
The dreload function does a recursive reload of a module: changes made
|
|
2374
|
The dreload function does a recursive reload of a module: changes made
|
|
2372
|
to the module since you imported will actually be available without
|
|
2375
|
to the module since you imported will actually be available without
|
|
2373
|
having to exit.
|
|
2376
|
having to exit.
|
|
2374
|
|
|
2377
|
|
|
2375
|
|
|
2378
|
|
|
2376
|
Verbose and colored exception traceback printouts
|
|
2379
|
Verbose and colored exception traceback printouts
|
|
2377
|
-------------------------------------------------
|
|
2380
|
-------------------------------------------------
|
|
2378
|
|
|
2381
|
|
|
2379
|
IPython provides the option to see very detailed exception tracebacks,
|
|
2382
|
IPython provides the option to see very detailed exception tracebacks,
|
|
2380
|
which can be especially useful when debugging large programs. You can
|
|
2383
|
which can be especially useful when debugging large programs. You can
|
|
2381
|
run any Python file with the %run function to benefit from these
|
|
2384
|
run any Python file with the %run function to benefit from these
|
|
2382
|
detailed tracebacks. Furthermore, both normal and verbose tracebacks can
|
|
2385
|
detailed tracebacks. Furthermore, both normal and verbose tracebacks can
|
|
2383
|
be colored (if your terminal supports it) which makes them much easier
|
|
2386
|
be colored (if your terminal supports it) which makes them much easier
|
|
2384
|
to parse visually.
|
|
2387
|
to parse visually.
|
|
2385
|
|
|
2388
|
|
|
2386
|
See the magic xmode and colors functions for details (just type %magic).
|
|
2389
|
See the magic xmode and colors functions for details (just type %magic).
|
|
2387
|
|
|
2390
|
|
|
2388
|
These features are basically a terminal version of Ka-Ping Yee's cgitb
|
|
2391
|
These features are basically a terminal version of Ka-Ping Yee's cgitb
|
|
2389
|
module, now part of the standard Python library.
|
|
2392
|
module, now part of the standard Python library.
|
|
2390
|
|
|
2393
|
|
|
2391
|
|
|
2394
|
|
|
2392
|
.. _Input caching:
|
|
2395
|
.. _input_caching:
|
|
2393
|
|
|
2396
|
|
|
2394
|
Input caching system
|
|
2397
|
Input caching system
|
|
2395
|
--------------------
|
|
2398
|
--------------------
|
|
2396
|
|
|
2399
|
|
|
2397
|
IPython offers numbered prompts (In/Out) with input and output caching.
|
|
2400
|
IPython offers numbered prompts (In/Out) with input and output caching.
|
|
2398
|
All input is saved and can be retrieved as variables (besides the usual
|
|
2401
|
All input is saved and can be retrieved as variables (besides the usual
|
|
2399
|
arrow key recall).
|
|
2402
|
arrow key recall).
|
|
2400
|
|
|
2403
|
|
|
2401
|
The following GLOBAL variables always exist (so don't overwrite them!):
|
|
2404
|
The following GLOBAL variables always exist (so don't overwrite them!):
|
|
2402
|
_i: stores previous input. _ii: next previous. _iii: next-next previous.
|
|
2405
|
_i: stores previous input. _ii: next previous. _iii: next-next previous.
|
|
2403
|
_ih : a list of all input _ih[n] is the input from line n and this list
|
|
2406
|
_ih : a list of all input _ih[n] is the input from line n and this list
|
|
2404
|
is aliased to the global variable In. If you overwrite In with a
|
|
2407
|
is aliased to the global variable In. If you overwrite In with a
|
|
2405
|
variable of your own, you can remake the assignment to the internal list
|
|
2408
|
variable of your own, you can remake the assignment to the internal list
|
|
2406
|
with a simple 'In=_ih'.
|
|
2409
|
with a simple 'In=_ih'.
|
|
2407
|
|
|
2410
|
|
|
2408
|
Additionally, global variables named _i<n> are dynamically created (<n>
|
|
2411
|
Additionally, global variables named _i<n> are dynamically created (<n>
|
|
2409
|
being the prompt counter), such that
|
|
2412
|
being the prompt counter), such that
|
|
2410
|
_i<n> == _ih[<n>] == In[<n>].
|
|
2413
|
_i<n> == _ih[<n>] == In[<n>].
|
|
2411
|
|
|
2414
|
|
|
2412
|
For example, what you typed at prompt 14 is available as _i14, _ih[14]
|
|
2415
|
For example, what you typed at prompt 14 is available as _i14, _ih[14]
|
|
2413
|
and In[14].
|
|
2416
|
and In[14].
|
|
2414
|
|
|
2417
|
|
|
2415
|
This allows you to easily cut and paste multi line interactive prompts
|
|
2418
|
This allows you to easily cut and paste multi line interactive prompts
|
|
2416
|
by printing them out: they print like a clean string, without prompt
|
|
2419
|
by printing them out: they print like a clean string, without prompt
|
|
2417
|
characters. You can also manipulate them like regular variables (they
|
|
2420
|
characters. You can also manipulate them like regular variables (they
|
|
2418
|
are strings), modify or exec them (typing 'exec _i9' will re-execute the
|
|
2421
|
are strings), modify or exec them (typing 'exec _i9' will re-execute the
|
|
2419
|
contents of input prompt 9, 'exec In[9:14]+In[18]' will re-execute lines
|
|
2422
|
contents of input prompt 9, 'exec In[9:14]+In[18]' will re-execute lines
|
|
2420
|
9 through 13 and line 18).
|
|
2423
|
9 through 13 and line 18).
|
|
2421
|
|
|
2424
|
|
|
2422
|
You can also re-execute multiple lines of input easily by using the
|
|
2425
|
You can also re-execute multiple lines of input easily by using the
|
|
2423
|
magic %macro function (which automates the process and allows
|
|
2426
|
magic %macro function (which automates the process and allows
|
|
2424
|
re-execution without having to type 'exec' every time). The macro system
|
|
2427
|
re-execution without having to type 'exec' every time). The macro system
|
|
2425
|
also allows you to re-execute previous lines which include magic
|
|
2428
|
also allows you to re-execute previous lines which include magic
|
|
2426
|
function calls (which require special processing). Type %macro? or see
|
|
2429
|
function calls (which require special processing). Type %macro? or see
|
|
2427
|
sec. 6.2 <#sec:magic> for more details on the macro system.
|
|
2430
|
sec. 6.2 <#sec:magic> for more details on the macro system.
|
|
2428
|
|
|
2431
|
|
|
2429
|
A history function %hist allows you to see any part of your input
|
|
2432
|
A history function %hist allows you to see any part of your input
|
|
2430
|
history by printing a range of the _i variables.
|
|
2433
|
history by printing a range of the _i variables.
|
|
2431
|
|
|
2434
|
|
|
2432
|
.. _Output caching:
|
|
2435
|
.. _output_caching:
|
|
2433
|
|
|
2436
|
|
|
2434
|
Output caching system
|
|
2437
|
Output caching system
|
|
2435
|
---------------------
|
|
2438
|
---------------------
|
|
2436
|
|
|
2439
|
|
|
2437
|
For output that is returned from actions, a system similar to the input
|
|
2440
|
For output that is returned from actions, a system similar to the input
|
|
2438
|
cache exists but using _ instead of _i. Only actions that produce a
|
|
2441
|
cache exists but using _ instead of _i. Only actions that produce a
|
|
2439
|
result (NOT assignments, for example) are cached. If you are familiar
|
|
2442
|
result (NOT assignments, for example) are cached. If you are familiar
|
|
2440
|
with Mathematica, IPython's _ variables behave exactly like
|
|
2443
|
with Mathematica, IPython's _ variables behave exactly like
|
|
2441
|
Mathematica's % variables.
|
|
2444
|
Mathematica's % variables.
|
|
2442
|
|
|
2445
|
|
|
2443
|
The following GLOBAL variables always exist (so don't overwrite them!):
|
|
2446
|
The following GLOBAL variables always exist (so don't overwrite them!):
|
|
2444
|
|
|
2447
|
|
|
2445
|
* [_] (a single underscore) : stores previous output, like Python's
|
|
2448
|
* [_] (a single underscore) : stores previous output, like Python's
|
|
2446
|
default interpreter.
|
|
2449
|
default interpreter.
|
|
2447
|
* [__] (two underscores): next previous.
|
|
2450
|
* [__] (two underscores): next previous.
|
|
2448
|
* [___] (three underscores): next-next previous.
|
|
2451
|
* [___] (three underscores): next-next previous.
|
|
2449
|
|
|
2452
|
|
|
2450
|
Additionally, global variables named _<n> are dynamically created (<n>
|
|
2453
|
Additionally, global variables named _<n> are dynamically created (<n>
|
|
2451
|
being the prompt counter), such that the result of output <n> is always
|
|
2454
|
being the prompt counter), such that the result of output <n> is always
|
|
2452
|
available as _<n> (don't use the angle brackets, just the number, e.g.
|
|
2455
|
available as _<n> (don't use the angle brackets, just the number, e.g.
|
|
2453
|
_21).
|
|
2456
|
_21).
|
|
2454
|
|
|
2457
|
|
|
2455
|
These global variables are all stored in a global dictionary (not a
|
|
2458
|
These global variables are all stored in a global dictionary (not a
|
|
2456
|
list, since it only has entries for lines which returned a result)
|
|
2459
|
list, since it only has entries for lines which returned a result)
|
|
2457
|
available under the names _oh and Out (similar to _ih and In). So the
|
|
2460
|
available under the names _oh and Out (similar to _ih and In). So the
|
|
2458
|
output from line 12 can be obtained as _12, Out[12] or _oh[12]. If you
|
|
2461
|
output from line 12 can be obtained as _12, Out[12] or _oh[12]. If you
|
|
2459
|
accidentally overwrite the Out variable you can recover it by typing
|
|
2462
|
accidentally overwrite the Out variable you can recover it by typing
|
|
2460
|
'Out=_oh' at the prompt.
|
|
2463
|
'Out=_oh' at the prompt.
|
|
2461
|
|
|
2464
|
|
|
2462
|
This system obviously can potentially put heavy memory demands on your
|
|
2465
|
This system obviously can potentially put heavy memory demands on your
|
|
2463
|
system, since it prevents Python's garbage collector from removing any
|
|
2466
|
system, since it prevents Python's garbage collector from removing any
|
|
2464
|
previously computed results. You can control how many results are kept
|
|
2467
|
previously computed results. You can control how many results are kept
|
|
2465
|
in memory with the option (at the command line or in your ipythonrc
|
|
2468
|
in memory with the option (at the command line or in your ipythonrc
|
|
2466
|
file) cache_size. If you set it to 0, the whole system is completely
|
|
2469
|
file) cache_size. If you set it to 0, the whole system is completely
|
|
2467
|
disabled and the prompts revert to the classic '>>>' of normal Python.
|
|
2470
|
disabled and the prompts revert to the classic '>>>' of normal Python.
|
|
2468
|
|
|
2471
|
|
|
2469
|
|
|
2472
|
|
|
2470
|
Directory history
|
|
2473
|
Directory history
|
|
2471
|
-----------------
|
|
2474
|
-----------------
|
|
2472
|
|
|
2475
|
|
|
2473
|
Your history of visited directories is kept in the global list _dh, and
|
|
2476
|
Your history of visited directories is kept in the global list _dh, and
|
|
2474
|
the magic %cd command can be used to go to any entry in that list. The
|
|
2477
|
the magic %cd command can be used to go to any entry in that list. The
|
|
2475
|
%dhist command allows you to view this history. do ``cd -<TAB`` to
|
|
2478
|
%dhist command allows you to view this history. do ``cd -<TAB`` to
|
|
2476
|
conventiently view the directory history.
|
|
2479
|
conventiently view the directory history.
|
|
2477
|
|
|
2480
|
|
|
2478
|
|
|
2481
|
|
|
2479
|
Automatic parentheses and quotes
|
|
2482
|
Automatic parentheses and quotes
|
|
2480
|
--------------------------------
|
|
2483
|
--------------------------------
|
|
2481
|
|
|
2484
|
|
|
2482
|
These features were adapted from Nathan Gray's LazyPython. They are
|
|
2485
|
These features were adapted from Nathan Gray's LazyPython. They are
|
|
2483
|
meant to allow less typing for common situations.
|
|
2486
|
meant to allow less typing for common situations.
|
|
2484
|
|
|
2487
|
|
|
2485
|
|
|
2488
|
|
|
2486
|
Automatic parentheses
|
|
2489
|
Automatic parentheses
|
|
2487
|
---------------------
|
|
2490
|
---------------------
|
|
2488
|
|
|
2491
|
|
|
2489
|
Callable objects (i.e. functions, methods, etc) can be invoked like this
|
|
2492
|
Callable objects (i.e. functions, methods, etc) can be invoked like this
|
|
2490
|
(notice the commas between the arguments)::
|
|
2493
|
(notice the commas between the arguments)::
|
|
2491
|
|
|
2494
|
|
|
2492
|
>>> callable_ob arg1, arg2, arg3
|
|
2495
|
>>> callable_ob arg1, arg2, arg3
|
|
2493
|
|
|
2496
|
|
|
2494
|
and the input will be translated to this::
|
|
2497
|
and the input will be translated to this::
|
|
2495
|
|
|
2498
|
|
|
2496
|
-> callable_ob(arg1, arg2, arg3)
|
|
2499
|
-> callable_ob(arg1, arg2, arg3)
|
|
2497
|
|
|
2500
|
|
|
2498
|
You can force automatic parentheses by using '/' as the first character
|
|
2501
|
You can force automatic parentheses by using '/' as the first character
|
|
2499
|
of a line. For example::
|
|
2502
|
of a line. For example::
|
|
2500
|
|
|
2503
|
|
|
2501
|
>>> /globals # becomes 'globals()'
|
|
2504
|
>>> /globals # becomes 'globals()'
|
|
2502
|
|
|
2505
|
|
|
2503
|
Note that the '/' MUST be the first character on the line! This won't work::
|
|
2506
|
Note that the '/' MUST be the first character on the line! This won't work::
|
|
2504
|
|
|
2507
|
|
|
2505
|
>>> print /globals # syntax error
|
|
2508
|
>>> print /globals # syntax error
|
|
2506
|
|
|
2509
|
|
|
2507
|
In most cases the automatic algorithm should work, so you should rarely
|
|
2510
|
In most cases the automatic algorithm should work, so you should rarely
|
|
2508
|
need to explicitly invoke /. One notable exception is if you are trying
|
|
2511
|
need to explicitly invoke /. One notable exception is if you are trying
|
|
2509
|
to call a function with a list of tuples as arguments (the parenthesis
|
|
2512
|
to call a function with a list of tuples as arguments (the parenthesis
|
|
2510
|
will confuse IPython)::
|
|
2513
|
will confuse IPython)::
|
|
2511
|
|
|
2514
|
|
|
2512
|
In [1]: zip (1,2,3),(4,5,6) # won't work
|
|
2515
|
In [1]: zip (1,2,3),(4,5,6) # won't work
|
|
2513
|
|
|
2516
|
|
|
2514
|
but this will work::
|
|
2517
|
but this will work::
|
|
2515
|
|
|
2518
|
|
|
2516
|
In [2]: /zip (1,2,3),(4,5,6)
|
|
2519
|
In [2]: /zip (1,2,3),(4,5,6)
|
|
2517
|
---> zip ((1,2,3),(4,5,6))
|
|
2520
|
---> zip ((1,2,3),(4,5,6))
|
|
2518
|
Out[2]= [(1, 4), (2, 5), (3, 6)]
|
|
2521
|
Out[2]= [(1, 4), (2, 5), (3, 6)]
|
|
2519
|
|
|
2522
|
|
|
2520
|
IPython tells you that it has altered your command line by displaying
|
|
2523
|
IPython tells you that it has altered your command line by displaying
|
|
2521
|
the new command line preceded by ->. e.g.::
|
|
2524
|
the new command line preceded by ->. e.g.::
|
|
2522
|
|
|
2525
|
|
|
2523
|
In [18]: callable list
|
|
2526
|
In [18]: callable list
|
|
2524
|
----> callable (list)
|
|
2527
|
----> callable (list)
|
|
2525
|
|
|
2528
|
|
|
2526
|
|
|
2529
|
|
|
2527
|
Automatic quoting
|
|
2530
|
Automatic quoting
|
|
2528
|
-----------------
|
|
2531
|
-----------------
|
|
2529
|
|
|
2532
|
|
|
2530
|
You can force automatic quoting of a function's arguments by using ','
|
|
2533
|
You can force automatic quoting of a function's arguments by using ','
|
|
2531
|
or ';' as the first character of a line. For example::
|
|
2534
|
or ';' as the first character of a line. For example::
|
|
2532
|
|
|
2535
|
|
|
2533
|
>>> ,my_function /home/me # becomes my_function("/home/me")
|
|
2536
|
>>> ,my_function /home/me # becomes my_function("/home/me")
|
|
2534
|
|
|
2537
|
|
|
2535
|
If you use ';' instead, the whole argument is quoted as a single string
|
|
2538
|
If you use ';' instead, the whole argument is quoted as a single string
|
|
2536
|
(while ',' splits on whitespace)::
|
|
2539
|
(while ',' splits on whitespace)::
|
|
2537
|
|
|
2540
|
|
|
2538
|
>>> ,my_function a b c # becomes my_function("a","b","c")
|
|
2541
|
>>> ,my_function a b c # becomes my_function("a","b","c")
|
|
2539
|
|
|
2542
|
|
|
2540
|
>>> ;my_function a b c # becomes my_function("a b c")
|
|
2543
|
>>> ;my_function a b c # becomes my_function("a b c")
|
|
2541
|
|
|
2544
|
|
|
2542
|
Note that the ',' or ';' MUST be the first character on the line! This
|
|
2545
|
Note that the ',' or ';' MUST be the first character on the line! This
|
|
2543
|
won't work::
|
|
2546
|
won't work::
|
|
2544
|
|
|
2547
|
|
|
2545
|
>>> x = ,my_function /home/me # syntax error
|
|
2548
|
>>> x = ,my_function /home/me # syntax error
|
|
2546
|
|
|
2549
|
|
|
2547
|
IPython as your default Python environment
|
|
2550
|
IPython as your default Python environment
|
|
2548
|
==========================================
|
|
2551
|
==========================================
|
|
2549
|
|
|
2552
|
|
|
2550
|
Python honors the environment variable PYTHONSTARTUP and will execute at
|
|
2553
|
Python honors the environment variable PYTHONSTARTUP and will execute at
|
|
2551
|
startup the file referenced by this variable. If you put at the end of
|
|
2554
|
startup the file referenced by this variable. If you put at the end of
|
|
2552
|
this file the following two lines of code::
|
|
2555
|
this file the following two lines of code::
|
|
2553
|
|
|
2556
|
|
|
2554
|
import IPython
|
|
2557
|
import IPython
|
|
2555
|
IPython.Shell.IPShell().mainloop(sys_exit=1)
|
|
2558
|
IPython.Shell.IPShell().mainloop(sys_exit=1)
|
|
2556
|
|
|
2559
|
|
|
2557
|
then IPython will be your working environment anytime you start Python.
|
|
2560
|
then IPython will be your working environment anytime you start Python.
|
|
2558
|
The sys_exit=1 is needed to have IPython issue a call to sys.exit() when
|
|
2561
|
The sys_exit=1 is needed to have IPython issue a call to sys.exit() when
|
|
2559
|
it finishes, otherwise you'll be back at the normal Python '>>>'
|
|
2562
|
it finishes, otherwise you'll be back at the normal Python '>>>'
|
|
2560
|
prompt.
|
|
2563
|
prompt.
|
|
2561
|
|
|
2564
|
|
|
2562
|
This is probably useful to developers who manage multiple Python
|
|
2565
|
This is probably useful to developers who manage multiple Python
|
|
2563
|
versions and don't want to have correspondingly multiple IPython
|
|
2566
|
versions and don't want to have correspondingly multiple IPython
|
|
2564
|
versions. Note that in this mode, there is no way to pass IPython any
|
|
2567
|
versions. Note that in this mode, there is no way to pass IPython any
|
|
2565
|
command-line options, as those are trapped first by Python itself.
|
|
2568
|
command-line options, as those are trapped first by Python itself.
|
|
2566
|
|
|
2569
|
|
|
2567
|
.. _Embedding:
|
|
2570
|
.. _Embedding:
|
|
2568
|
|
|
2571
|
|
|
2569
|
Embedding IPython
|
|
2572
|
Embedding IPython
|
|
2570
|
=================
|
|
2573
|
=================
|
|
2571
|
|
|
2574
|
|
|
2572
|
It is possible to start an IPython instance inside your own Python
|
|
2575
|
It is possible to start an IPython instance inside your own Python
|
|
2573
|
programs. This allows you to evaluate dynamically the state of your
|
|
2576
|
programs. This allows you to evaluate dynamically the state of your
|
|
2574
|
code, operate with your variables, analyze them, etc. Note however that
|
|
2577
|
code, operate with your variables, analyze them, etc. Note however that
|
|
2575
|
any changes you make to values while in the shell do not propagate back
|
|
2578
|
any changes you make to values while in the shell do not propagate back
|
|
2576
|
to the running code, so it is safe to modify your values because you
|
|
2579
|
to the running code, so it is safe to modify your values because you
|
|
2577
|
won't break your code in bizarre ways by doing so.
|
|
2580
|
won't break your code in bizarre ways by doing so.
|
|
2578
|
|
|
2581
|
|
|
2579
|
This feature allows you to easily have a fully functional python
|
|
2582
|
This feature allows you to easily have a fully functional python
|
|
2580
|
environment for doing object introspection anywhere in your code with a
|
|
2583
|
environment for doing object introspection anywhere in your code with a
|
|
2581
|
simple function call. In some cases a simple print statement is enough,
|
|
2584
|
simple function call. In some cases a simple print statement is enough,
|
|
2582
|
but if you need to do more detailed analysis of a code fragment this
|
|
2585
|
but if you need to do more detailed analysis of a code fragment this
|
|
2583
|
feature can be very valuable.
|
|
2586
|
feature can be very valuable.
|
|
2584
|
|
|
2587
|
|
|
2585
|
It can also be useful in scientific computing situations where it is
|
|
2588
|
It can also be useful in scientific computing situations where it is
|
|
2586
|
common to need to do some automatic, computationally intensive part and
|
|
2589
|
common to need to do some automatic, computationally intensive part and
|
|
2587
|
then stop to look at data, plots, etc.
|
|
2590
|
then stop to look at data, plots, etc.
|
|
2588
|
Opening an IPython instance will give you full access to your data and
|
|
2591
|
Opening an IPython instance will give you full access to your data and
|
|
2589
|
functions, and you can resume program execution once you are done with
|
|
2592
|
functions, and you can resume program execution once you are done with
|
|
2590
|
the interactive part (perhaps to stop again later, as many times as
|
|
2593
|
the interactive part (perhaps to stop again later, as many times as
|
|
2591
|
needed).
|
|
2594
|
needed).
|
|
2592
|
|
|
2595
|
|
|
2593
|
The following code snippet is the bare minimum you need to include in
|
|
2596
|
The following code snippet is the bare minimum you need to include in
|
|
2594
|
your Python programs for this to work (detailed examples follow later)::
|
|
2597
|
your Python programs for this to work (detailed examples follow later)::
|
|
2595
|
|
|
2598
|
|
|
2596
|
from IPython.Shell import IPShellEmbed
|
|
2599
|
from IPython.Shell import IPShellEmbed
|
|
2597
|
|
|
2600
|
|
|
2598
|
ipshell = IPShellEmbed()
|
|
2601
|
ipshell = IPShellEmbed()
|
|
2599
|
|
|
2602
|
|
|
2600
|
ipshell() # this call anywhere in your program will start IPython
|
|
2603
|
ipshell() # this call anywhere in your program will start IPython
|
|
2601
|
|
|
2604
|
|
|
2602
|
You can run embedded instances even in code which is itself being run at
|
|
2605
|
You can run embedded instances even in code which is itself being run at
|
|
2603
|
the IPython interactive prompt with '%run <filename>'. Since it's easy
|
|
2606
|
the IPython interactive prompt with '%run <filename>'. Since it's easy
|
|
2604
|
to get lost as to where you are (in your top-level IPython or in your
|
|
2607
|
to get lost as to where you are (in your top-level IPython or in your
|
|
2605
|
embedded one), it's a good idea in such cases to set the in/out prompts
|
|
2608
|
embedded one), it's a good idea in such cases to set the in/out prompts
|
|
2606
|
to something different for the embedded instances. The code examples
|
|
2609
|
to something different for the embedded instances. The code examples
|
|
2607
|
below illustrate this.
|
|
2610
|
below illustrate this.
|
|
2608
|
|
|
2611
|
|
|
2609
|
You can also have multiple IPython instances in your program and open
|
|
2612
|
You can also have multiple IPython instances in your program and open
|
|
2610
|
them separately, for example with different options for data
|
|
2613
|
them separately, for example with different options for data
|
|
2611
|
presentation. If you close and open the same instance multiple times,
|
|
2614
|
presentation. If you close and open the same instance multiple times,
|
|
2612
|
its prompt counters simply continue from each execution to the next.
|
|
2615
|
its prompt counters simply continue from each execution to the next.
|
|
2613
|
|
|
2616
|
|
|
2614
|
Please look at the docstrings in the Shell.py module for more details on
|
|
2617
|
Please look at the docstrings in the Shell.py module for more details on
|
|
2615
|
the use of this system.
|
|
2618
|
the use of this system.
|
|
2616
|
|
|
2619
|
|
|
2617
|
The following sample file illustrating how to use the embedding
|
|
2620
|
The following sample file illustrating how to use the embedding
|
|
2618
|
functionality is provided in the examples directory as example-embed.py.
|
|
2621
|
functionality is provided in the examples directory as example-embed.py.
|
|
2619
|
It should be fairly self-explanatory::
|
|
2622
|
It should be fairly self-explanatory::
|
|
2620
|
|
|
2623
|
|
|
2621
|
|
|
2624
|
|
|
2622
|
#!/usr/bin/env python
|
|
2625
|
#!/usr/bin/env python
|
|
2623
|
|
|
2626
|
|
|
2624
|
"""An example of how to embed an IPython shell into a running program.
|
|
2627
|
"""An example of how to embed an IPython shell into a running program.
|
|
2625
|
|
|
2628
|
|
|
2626
|
Please see the documentation in the IPython.Shell module for more details.
|
|
2629
|
Please see the documentation in the IPython.Shell module for more details.
|
|
2627
|
|
|
2630
|
|
|
2628
|
The accompanying file example-embed-short.py has quick code fragments for
|
|
2631
|
The accompanying file example-embed-short.py has quick code fragments for
|
|
2629
|
embedding which you can cut and paste in your code once you understand how
|
|
2632
|
embedding which you can cut and paste in your code once you understand how
|
|
2630
|
things work.
|
|
2633
|
things work.
|
|
2631
|
|
|
2634
|
|
|
2632
|
The code in this file is deliberately extra-verbose, meant for learning."""
|
|
2635
|
The code in this file is deliberately extra-verbose, meant for learning."""
|
|
2633
|
|
|
2636
|
|
|
2634
|
# The basics to get you going:
|
|
2637
|
# The basics to get you going:
|
|
2635
|
|
|
2638
|
|
|
2636
|
# IPython sets the __IPYTHON__ variable so you can know if you have nested
|
|
2639
|
# IPython sets the __IPYTHON__ variable so you can know if you have nested
|
|
2637
|
# copies running.
|
|
2640
|
# copies running.
|
|
2638
|
|
|
2641
|
|
|
2639
|
# Try running this code both at the command line and from inside IPython (with
|
|
2642
|
# Try running this code both at the command line and from inside IPython (with
|
|
2640
|
# %run example-embed.py)
|
|
2643
|
# %run example-embed.py)
|
|
2641
|
try:
|
|
2644
|
try:
|
|
2642
|
__IPYTHON__
|
|
2645
|
__IPYTHON__
|
|
2643
|
except NameError:
|
|
2646
|
except NameError:
|
|
2644
|
nested = 0
|
|
2647
|
nested = 0
|
|
2645
|
args = ['']
|
|
2648
|
args = ['']
|
|
2646
|
else:
|
|
2649
|
else:
|
|
2647
|
print "Running nested copies of IPython."
|
|
2650
|
print "Running nested copies of IPython."
|
|
2648
|
print "The prompts for the nested copy have been modified"
|
|
2651
|
print "The prompts for the nested copy have been modified"
|
|
2649
|
nested = 1
|
|
2652
|
nested = 1
|
|
2650
|
# what the embedded instance will see as sys.argv:
|
|
2653
|
# what the embedded instance will see as sys.argv:
|
|
2651
|
args = ['-pi1','In <\\#>: ','-pi2',' .\\D.: ',
|
|
2654
|
args = ['-pi1','In <\\#>: ','-pi2',' .\\D.: ',
|
|
2652
|
'-po','Out<\\#>: ','-nosep']
|
|
2655
|
'-po','Out<\\#>: ','-nosep']
|
|
2653
|
|
|
2656
|
|
|
2654
|
# First import the embeddable shell class
|
|
2657
|
# First import the embeddable shell class
|
|
2655
|
from IPython.Shell import IPShellEmbed
|
|
2658
|
from IPython.Shell import IPShellEmbed
|
|
2656
|
|
|
2659
|
|
|
2657
|
# Now create an instance of the embeddable shell. The first argument is a
|
|
2660
|
# Now create an instance of the embeddable shell. The first argument is a
|
|
2658
|
# string with options exactly as you would type them if you were starting
|
|
2661
|
# string with options exactly as you would type them if you were starting
|
|
2659
|
# IPython at the system command line. Any parameters you want to define for
|
|
2662
|
# IPython at the system command line. Any parameters you want to define for
|
|
2660
|
# configuration can thus be specified here.
|
|
2663
|
# configuration can thus be specified here.
|
|
2661
|
ipshell = IPShellEmbed(args,
|
|
2664
|
ipshell = IPShellEmbed(args,
|
|
2662
|
banner = 'Dropping into IPython',
|
|
2665
|
banner = 'Dropping into IPython',
|
|
2663
|
exit_msg = 'Leaving Interpreter, back to program.')
|
|
2666
|
exit_msg = 'Leaving Interpreter, back to program.')
|
|
2664
|
|
|
2667
|
|
|
2665
|
# Make a second instance, you can have as many as you want.
|
|
2668
|
# Make a second instance, you can have as many as you want.
|
|
2666
|
if nested:
|
|
2669
|
if nested:
|
|
2667
|
args[1] = 'In2<\\#>'
|
|
2670
|
args[1] = 'In2<\\#>'
|
|
2668
|
else:
|
|
2671
|
else:
|
|
2669
|
args = ['-pi1','In2<\\#>: ','-pi2',' .\\D.: ',
|
|
2672
|
args = ['-pi1','In2<\\#>: ','-pi2',' .\\D.: ',
|
|
2670
|
'-po','Out<\\#>: ','-nosep']
|
|
2673
|
'-po','Out<\\#>: ','-nosep']
|
|
2671
|
ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.')
|
|
2674
|
ipshell2 = IPShellEmbed(args,banner = 'Second IPython instance.')
|
|
2672
|
|
|
2675
|
|
|
2673
|
print '\nHello. This is printed from the main controller program.\n'
|
|
2676
|
print '\nHello. This is printed from the main controller program.\n'
|
|
2674
|
|
|
2677
|
|
|
2675
|
# You can then call ipshell() anywhere you need it (with an optional
|
|
2678
|
# You can then call ipshell() anywhere you need it (with an optional
|
|
2676
|
# message):
|
|
2679
|
# message):
|
|
2677
|
ipshell('***Called from top level. '
|
|
2680
|
ipshell('***Called from top level. '
|
|
2678
|
'Hit Ctrl-D to exit interpreter and continue program.\n'
|
|
2681
|
'Hit Ctrl-D to exit interpreter and continue program.\n'
|
|
2679
|
'Note that if you use %kill_embedded, you can fully deactivate\n'
|
|
2682
|
'Note that if you use %kill_embedded, you can fully deactivate\n'
|
|
2680
|
'This embedded instance so it will never turn on again')
|
|
2683
|
'This embedded instance so it will never turn on again')
|
|
2681
|
|
|
2684
|
|
|
2682
|
print '\nBack in caller program, moving along...\n'
|
|
2685
|
print '\nBack in caller program, moving along...\n'
|
|
2683
|
|
|
2686
|
|
|
2684
|
#---------------------------------------------------------------------------
|
|
2687
|
#---------------------------------------------------------------------------
|
|
2685
|
# More details:
|
|
2688
|
# More details:
|
|
2686
|
|
|
2689
|
|
|
2687
|
# IPShellEmbed instances don't print the standard system banner and
|
|
2690
|
# IPShellEmbed instances don't print the standard system banner and
|
|
2688
|
# messages. The IPython banner (which actually may contain initialization
|
|
2691
|
# messages. The IPython banner (which actually may contain initialization
|
|
2689
|
# messages) is available as <instance>.IP.BANNER in case you want it.
|
|
2692
|
# messages) is available as <instance>.IP.BANNER in case you want it.
|
|
2690
|
|
|
2693
|
|
|
2691
|
# IPShellEmbed instances print the following information everytime they
|
|
2694
|
# IPShellEmbed instances print the following information everytime they
|
|
2692
|
# start:
|
|
2695
|
# start:
|
|
2693
|
|
|
2696
|
|
|
2694
|
# - A global startup banner.
|
|
2697
|
# - A global startup banner.
|
|
2695
|
|
|
2698
|
|
|
2696
|
# - A call-specific header string, which you can use to indicate where in the
|
|
2699
|
# - A call-specific header string, which you can use to indicate where in the
|
|
2697
|
# execution flow the shell is starting.
|
|
2700
|
# execution flow the shell is starting.
|
|
2698
|
|
|
2701
|
|
|
2699
|
# They also print an exit message every time they exit.
|
|
2702
|
# They also print an exit message every time they exit.
|
|
2700
|
|
|
2703
|
|
|
2701
|
# Both the startup banner and the exit message default to None, and can be set
|
|
2704
|
# Both the startup banner and the exit message default to None, and can be set
|
|
2702
|
# either at the instance constructor or at any other time with the
|
|
2705
|
# either at the instance constructor or at any other time with the
|
|
2703
|
# set_banner() and set_exit_msg() methods.
|
|
2706
|
# set_banner() and set_exit_msg() methods.
|
|
2704
|
|
|
2707
|
|
|
2705
|
# The shell instance can be also put in 'dummy' mode globally or on a per-call
|
|
2708
|
# The shell instance can be also put in 'dummy' mode globally or on a per-call
|
|
2706
|
# basis. This gives you fine control for debugging without having to change
|
|
2709
|
# basis. This gives you fine control for debugging without having to change
|
|
2707
|
# code all over the place.
|
|
2710
|
# code all over the place.
|
|
2708
|
|
|
2711
|
|
|
2709
|
# The code below illustrates all this.
|
|
2712
|
# The code below illustrates all this.
|
|
2710
|
|
|
2713
|
|
|
2711
|
|
|
2714
|
|
|
2712
|
# This is how the global banner and exit_msg can be reset at any point
|
|
2715
|
# This is how the global banner and exit_msg can be reset at any point
|
|
2713
|
ipshell.set_banner('Entering interpreter - New Banner')
|
|
2716
|
ipshell.set_banner('Entering interpreter - New Banner')
|
|
2714
|
ipshell.set_exit_msg('Leaving interpreter - New exit_msg')
|
|
2717
|
ipshell.set_exit_msg('Leaving interpreter - New exit_msg')
|
|
2715
|
|
|
2718
|
|
|
2716
|
def foo(m):
|
|
2719
|
def foo(m):
|
|
2717
|
s = 'spam'
|
|
2720
|
s = 'spam'
|
|
2718
|
ipshell('***In foo(). Try @whos, or print s or m:')
|
|
2721
|
ipshell('***In foo(). Try @whos, or print s or m:')
|
|
2719
|
print 'foo says m = ',m
|
|
2722
|
print 'foo says m = ',m
|
|
2720
|
|
|
2723
|
|
|
2721
|
def bar(n):
|
|
2724
|
def bar(n):
|
|
2722
|
s = 'eggs'
|
|
2725
|
s = 'eggs'
|
|
2723
|
ipshell('***In bar(). Try @whos, or print s or n:')
|
|
2726
|
ipshell('***In bar(). Try @whos, or print s or n:')
|
|
2724
|
print 'bar says n = ',n
|
|
2727
|
print 'bar says n = ',n
|
|
2725
|
|
|
2728
|
|
|
2726
|
# Some calls to the above functions which will trigger IPython:
|
|
2729
|
# Some calls to the above functions which will trigger IPython:
|
|
2727
|
print 'Main program calling foo("eggs")\n'
|
|
2730
|
print 'Main program calling foo("eggs")\n'
|
|
2728
|
foo('eggs')
|
|
2731
|
foo('eggs')
|
|
2729
|
|
|
2732
|
|
|
2730
|
# The shell can be put in 'dummy' mode where calls to it silently return. This
|
|
2733
|
# The shell can be put in 'dummy' mode where calls to it silently return. This
|
|
2731
|
# allows you, for example, to globally turn off debugging for a program with a
|
|
2734
|
# allows you, for example, to globally turn off debugging for a program with a
|
|
2732
|
# single call.
|
|
2735
|
# single call.
|
|
2733
|
ipshell.set_dummy_mode(1)
|
|
2736
|
ipshell.set_dummy_mode(1)
|
|
2734
|
print '\nTrying to call IPython which is now "dummy":'
|
|
2737
|
print '\nTrying to call IPython which is now "dummy":'
|
|
2735
|
ipshell()
|
|
2738
|
ipshell()
|
|
2736
|
print 'Nothing happened...'
|
|
2739
|
print 'Nothing happened...'
|
|
2737
|
# The global 'dummy' mode can still be overridden for a single call
|
|
2740
|
# The global 'dummy' mode can still be overridden for a single call
|
|
2738
|
print '\nOverriding dummy mode manually:'
|
|
2741
|
print '\nOverriding dummy mode manually:'
|
|
2739
|
ipshell(dummy=0)
|
|
2742
|
ipshell(dummy=0)
|
|
2740
|
|
|
2743
|
|
|
2741
|
# Reactivate the IPython shell
|
|
2744
|
# Reactivate the IPython shell
|
|
2742
|
ipshell.set_dummy_mode(0)
|
|
2745
|
ipshell.set_dummy_mode(0)
|
|
2743
|
|
|
2746
|
|
|
2744
|
print 'You can even have multiple embedded instances:'
|
|
2747
|
print 'You can even have multiple embedded instances:'
|
|
2745
|
ipshell2()
|
|
2748
|
ipshell2()
|
|
2746
|
|
|
2749
|
|
|
2747
|
print '\nMain program calling bar("spam")\n'
|
|
2750
|
print '\nMain program calling bar("spam")\n'
|
|
2748
|
bar('spam')
|
|
2751
|
bar('spam')
|
|
2749
|
|
|
2752
|
|
|
2750
|
print 'Main program finished. Bye!'
|
|
2753
|
print 'Main program finished. Bye!'
|
|
2751
|
|
|
2754
|
|
|
2752
|
#********************** End of file <example-embed.py> ***********************
|
|
2755
|
#********************** End of file <example-embed.py> ***********************
|
|
2753
|
|
|
2756
|
|
|
2754
|
Once you understand how the system functions, you can use the following
|
|
2757
|
Once you understand how the system functions, you can use the following
|
|
2755
|
code fragments in your programs which are ready for cut and paste::
|
|
2758
|
code fragments in your programs which are ready for cut and paste::
|
|
2756
|
|
|
2759
|
|
|
2757
|
|
|
2760
|
|
|
2758
|
"""Quick code snippets for embedding IPython into other programs.
|
|
2761
|
"""Quick code snippets for embedding IPython into other programs.
|
|
2759
|
|
|
2762
|
|
|
2760
|
See example-embed.py for full details, this file has the bare minimum code for
|
|
2763
|
See example-embed.py for full details, this file has the bare minimum code for
|
|
2761
|
cut and paste use once you understand how to use the system."""
|
|
2764
|
cut and paste use once you understand how to use the system."""
|
|
2762
|
|
|
2765
|
|
|
2763
|
#---------------------------------------------------------------------------
|
|
2766
|
#---------------------------------------------------------------------------
|
|
2764
|
# This code loads IPython but modifies a few things if it detects it's running
|
|
2767
|
# This code loads IPython but modifies a few things if it detects it's running
|
|
2765
|
# embedded in another IPython session (helps avoid confusion)
|
|
2768
|
# embedded in another IPython session (helps avoid confusion)
|
|
2766
|
|
|
2769
|
|
|
2767
|
try:
|
|
2770
|
try:
|
|
2768
|
__IPYTHON__
|
|
2771
|
__IPYTHON__
|
|
2769
|
except NameError:
|
|
2772
|
except NameError:
|
|
2770
|
argv = ['']
|
|
2773
|
argv = ['']
|
|
2771
|
banner = exit_msg = ''
|
|
2774
|
banner = exit_msg = ''
|
|
2772
|
else:
|
|
2775
|
else:
|
|
2773
|
# Command-line options for IPython (a list like sys.argv)
|
|
2776
|
# Command-line options for IPython (a list like sys.argv)
|
|
2774
|
argv = ['-pi1','In <\\#>:','-pi2',' .\\D.:','-po','Out<\\#>:']
|
|
2777
|
argv = ['-pi1','In <\\#>:','-pi2',' .\\D.:','-po','Out<\\#>:']
|
|
2775
|
banner = '*** Nested interpreter ***'
|
|
2778
|
banner = '*** Nested interpreter ***'
|
|
2776
|
exit_msg = '*** Back in main IPython ***'
|
|
2779
|
exit_msg = '*** Back in main IPython ***'
|
|
2777
|
|
|
2780
|
|
|
2778
|
# First import the embeddable shell class
|
|
2781
|
# First import the embeddable shell class
|
|
2779
|
from IPython.Shell import IPShellEmbed
|
|
2782
|
from IPython.Shell import IPShellEmbed
|
|
2780
|
# Now create the IPython shell instance. Put ipshell() anywhere in your code
|
|
2783
|
# Now create the IPython shell instance. Put ipshell() anywhere in your code
|
|
2781
|
# where you want it to open.
|
|
2784
|
# where you want it to open.
|
|
2782
|
ipshell = IPShellEmbed(argv,banner=banner,exit_msg=exit_msg)
|
|
2785
|
ipshell = IPShellEmbed(argv,banner=banner,exit_msg=exit_msg)
|
|
2783
|
|
|
2786
|
|
|
2784
|
#---------------------------------------------------------------------------
|
|
2787
|
#---------------------------------------------------------------------------
|
|
2785
|
# This code will load an embeddable IPython shell always with no changes for
|
|
2788
|
# This code will load an embeddable IPython shell always with no changes for
|
|
2786
|
# nested embededings.
|
|
2789
|
# nested embededings.
|
|
2787
|
|
|
2790
|
|
|
2788
|
from IPython.Shell import IPShellEmbed
|
|
2791
|
from IPython.Shell import IPShellEmbed
|
|
2789
|
ipshell = IPShellEmbed()
|
|
2792
|
ipshell = IPShellEmbed()
|
|
2790
|
# Now ipshell() will open IPython anywhere in the code.
|
|
2793
|
# Now ipshell() will open IPython anywhere in the code.
|
|
2791
|
|
|
2794
|
|
|
2792
|
#---------------------------------------------------------------------------
|
|
2795
|
#---------------------------------------------------------------------------
|
|
2793
|
# This code loads an embeddable shell only if NOT running inside
|
|
2796
|
# This code loads an embeddable shell only if NOT running inside
|
|
2794
|
# IPython. Inside IPython, the embeddable shell variable ipshell is just a
|
|
2797
|
# IPython. Inside IPython, the embeddable shell variable ipshell is just a
|
|
2795
|
# dummy function.
|
|
2798
|
# dummy function.
|
|
2796
|
|
|
2799
|
|
|
2797
|
try:
|
|
2800
|
try:
|
|
2798
|
__IPYTHON__
|
|
2801
|
__IPYTHON__
|
|
2799
|
except NameError:
|
|
2802
|
except NameError:
|
|
2800
|
from IPython.Shell import IPShellEmbed
|
|
2803
|
from IPython.Shell import IPShellEmbed
|
|
2801
|
ipshell = IPShellEmbed()
|
|
2804
|
ipshell = IPShellEmbed()
|
|
2802
|
# Now ipshell() will open IPython anywhere in the code
|
|
2805
|
# Now ipshell() will open IPython anywhere in the code
|
|
2803
|
else:
|
|
2806
|
else:
|
|
2804
|
# Define a dummy ipshell() so the same code doesn't crash inside an
|
|
2807
|
# Define a dummy ipshell() so the same code doesn't crash inside an
|
|
2805
|
# interactive IPython
|
|
2808
|
# interactive IPython
|
|
2806
|
def ipshell(): pass
|
|
2809
|
def ipshell(): pass
|
|
2807
|
|
|
2810
|
|
|
2808
|
#******************* End of file <example-embed-short.py> ********************
|
|
2811
|
#******************* End of file <example-embed-short.py> ********************
|
|
2809
|
|
|
2812
|
|
|
2810
|
Using the Python debugger (pdb)
|
|
2813
|
Using the Python debugger (pdb)
|
|
2811
|
===============================
|
|
2814
|
===============================
|
|
2812
|
|
|
2815
|
|
|
2813
|
Running entire programs via pdb
|
|
2816
|
Running entire programs via pdb
|
|
2814
|
-------------------------------
|
|
2817
|
-------------------------------
|
|
2815
|
|
|
2818
|
|
|
2816
|
pdb, the Python debugger, is a powerful interactive debugger which
|
|
2819
|
pdb, the Python debugger, is a powerful interactive debugger which
|
|
2817
|
allows you to step through code, set breakpoints, watch variables,
|
|
2820
|
allows you to step through code, set breakpoints, watch variables,
|
|
2818
|
etc. IPython makes it very easy to start any script under the control
|
|
2821
|
etc. IPython makes it very easy to start any script under the control
|
|
2819
|
of pdb, regardless of whether you have wrapped it into a 'main()'
|
|
2822
|
of pdb, regardless of whether you have wrapped it into a 'main()'
|
|
2820
|
function or not. For this, simply type '%run -d myscript' at an
|
|
2823
|
function or not. For this, simply type '%run -d myscript' at an
|
|
2821
|
IPython prompt. See the %run command's documentation (via '%run?' or
|
|
2824
|
IPython prompt. See the %run command's documentation (via '%run?' or
|
|
2822
|
in Sec. magic_ for more details, including how to control where pdb
|
|
2825
|
in Sec. magic_ for more details, including how to control where pdb
|
|
2823
|
will stop execution first.
|
|
2826
|
will stop execution first.
|
|
2824
|
|
|
2827
|
|
|
2825
|
For more information on the use of the pdb debugger, read the included
|
|
2828
|
For more information on the use of the pdb debugger, read the included
|
|
2826
|
pdb.doc file (part of the standard Python distribution). On a stock
|
|
2829
|
pdb.doc file (part of the standard Python distribution). On a stock
|
|
2827
|
Linux system it is located at /usr/lib/python2.3/pdb.doc, but the
|
|
2830
|
Linux system it is located at /usr/lib/python2.3/pdb.doc, but the
|
|
2828
|
easiest way to read it is by using the help() function of the pdb module
|
|
2831
|
easiest way to read it is by using the help() function of the pdb module
|
|
2829
|
as follows (in an IPython prompt):
|
|
2832
|
as follows (in an IPython prompt):
|
|
2830
|
|
|
2833
|
|
|
2831
|
In [1]: import pdb
|
|
2834
|
In [1]: import pdb
|
|
2832
|
In [2]: pdb.help()
|
|
2835
|
In [2]: pdb.help()
|
|
2833
|
|
|
2836
|
|
|
2834
|
This will load the pdb.doc document in a file viewer for you automatically.
|
|
2837
|
This will load the pdb.doc document in a file viewer for you automatically.
|
|
2835
|
|
|
2838
|
|
|
2836
|
|
|
2839
|
|
|
2837
|
Automatic invocation of pdb on exceptions
|
|
2840
|
Automatic invocation of pdb on exceptions
|
|
2838
|
-----------------------------------------
|
|
2841
|
-----------------------------------------
|
|
2839
|
|
|
2842
|
|
|
2840
|
IPython, if started with the -pdb option (or if the option is set in
|
|
2843
|
IPython, if started with the -pdb option (or if the option is set in
|
|
2841
|
your rc file) can call the Python pdb debugger every time your code
|
|
2844
|
your rc file) can call the Python pdb debugger every time your code
|
|
2842
|
triggers an uncaught exception. This feature
|
|
2845
|
triggers an uncaught exception. This feature
|
|
2843
|
can also be toggled at any time with the %pdb magic command. This can be
|
|
2846
|
can also be toggled at any time with the %pdb magic command. This can be
|
|
2844
|
extremely useful in order to find the origin of subtle bugs, because pdb
|
|
2847
|
extremely useful in order to find the origin of subtle bugs, because pdb
|
|
2845
|
opens up at the point in your code which triggered the exception, and
|
|
2848
|
opens up at the point in your code which triggered the exception, and
|
|
2846
|
while your program is at this point 'dead', all the data is still
|
|
2849
|
while your program is at this point 'dead', all the data is still
|
|
2847
|
available and you can walk up and down the stack frame and understand
|
|
2850
|
available and you can walk up and down the stack frame and understand
|
|
2848
|
the origin of the problem.
|
|
2851
|
the origin of the problem.
|
|
2849
|
|
|
2852
|
|
|
2850
|
Furthermore, you can use these debugging facilities both with the
|
|
2853
|
Furthermore, you can use these debugging facilities both with the
|
|
2851
|
embedded IPython mode and without IPython at all. For an embedded shell
|
|
2854
|
embedded IPython mode and without IPython at all. For an embedded shell
|
|
2852
|
(see sec. Embedding_), simply call the constructor with
|
|
2855
|
(see sec. Embedding_), simply call the constructor with
|
|
2853
|
'-pdb' in the argument string and automatically pdb will be called if an
|
|
2856
|
'-pdb' in the argument string and automatically pdb will be called if an
|
|
2854
|
uncaught exception is triggered by your code.
|
|
2857
|
uncaught exception is triggered by your code.
|
|
2855
|
|
|
2858
|
|
|
2856
|
For stand-alone use of the feature in your programs which do not use
|
|
2859
|
For stand-alone use of the feature in your programs which do not use
|
|
2857
|
IPython at all, put the following lines toward the top of your 'main'
|
|
2860
|
IPython at all, put the following lines toward the top of your 'main'
|
|
2858
|
routine::
|
|
2861
|
routine::
|
|
2859
|
|
|
2862
|
|
|
2860
|
import sys,IPython.ultraTB
|
|
2863
|
import sys,IPython.ultraTB
|
|
2861
|
sys.excepthook = IPython.ultraTB.FormattedTB(mode='Verbose',
|
|
2864
|
sys.excepthook = IPython.ultraTB.FormattedTB(mode='Verbose',
|
|
2862
|
color_scheme='Linux', call_pdb=1)
|
|
2865
|
color_scheme='Linux', call_pdb=1)
|
|
2863
|
|
|
2866
|
|
|
2864
|
The mode keyword can be either 'Verbose' or 'Plain', giving either very
|
|
2867
|
The mode keyword can be either 'Verbose' or 'Plain', giving either very
|
|
2865
|
detailed or normal tracebacks respectively. The color_scheme keyword can
|
|
2868
|
detailed or normal tracebacks respectively. The color_scheme keyword can
|
|
2866
|
be one of 'NoColor', 'Linux' (default) or 'LightBG'. These are the same
|
|
2869
|
be one of 'NoColor', 'Linux' (default) or 'LightBG'. These are the same
|
|
2867
|
options which can be set in IPython with -colors and -xmode.
|
|
2870
|
options which can be set in IPython with -colors and -xmode.
|
|
2868
|
|
|
2871
|
|
|
2869
|
This will give any of your programs detailed, colored tracebacks with
|
|
2872
|
This will give any of your programs detailed, colored tracebacks with
|
|
2870
|
automatic invocation of pdb.
|
|
2873
|
automatic invocation of pdb.
|
|
2871
|
|
|
2874
|
|
|
2872
|
|
|
2875
|
|
|
2873
|
Extensions for syntax processing
|
|
2876
|
Extensions for syntax processing
|
|
2874
|
================================
|
|
2877
|
================================
|
|
2875
|
|
|
2878
|
|
|
2876
|
This isn't for the faint of heart, because the potential for breaking
|
|
2879
|
This isn't for the faint of heart, because the potential for breaking
|
|
2877
|
things is quite high. But it can be a very powerful and useful feature.
|
|
2880
|
things is quite high. But it can be a very powerful and useful feature.
|
|
2878
|
In a nutshell, you can redefine the way IPython processes the user input
|
|
2881
|
In a nutshell, you can redefine the way IPython processes the user input
|
|
2879
|
line to accept new, special extensions to the syntax without needing to
|
|
2882
|
line to accept new, special extensions to the syntax without needing to
|
|
2880
|
change any of IPython's own code.
|
|
2883
|
change any of IPython's own code.
|
|
2881
|
|
|
2884
|
|
|
2882
|
In the IPython/Extensions directory you will find some examples
|
|
2885
|
In the IPython/Extensions directory you will find some examples
|
|
2883
|
supplied, which we will briefly describe now. These can be used 'as is'
|
|
2886
|
supplied, which we will briefly describe now. These can be used 'as is'
|
|
2884
|
(and both provide very useful functionality), or you can use them as a
|
|
2887
|
(and both provide very useful functionality), or you can use them as a
|
|
2885
|
starting point for writing your own extensions.
|
|
2888
|
starting point for writing your own extensions.
|
|
2886
|
|
|
2889
|
|
|
2887
|
|
|
2890
|
|
|
2888
|
Pasting of code starting with '>>> ' or '... '
|
|
2891
|
Pasting of code starting with '>>> ' or '... '
|
|
2889
|
----------------------------------------------
|
|
2892
|
----------------------------------------------
|
|
2890
|
|
|
2893
|
|
|
2891
|
In the python tutorial it is common to find code examples which have
|
|
2894
|
In the python tutorial it is common to find code examples which have
|
|
2892
|
been taken from real python sessions. The problem with those is that all
|
|
2895
|
been taken from real python sessions. The problem with those is that all
|
|
2893
|
the lines begin with either '>>> ' or '... ', which makes it impossible
|
|
2896
|
the lines begin with either '>>> ' or '... ', which makes it impossible
|
|
2894
|
to paste them all at once. One must instead do a line by line manual
|
|
2897
|
to paste them all at once. One must instead do a line by line manual
|
|
2895
|
copying, carefully removing the leading extraneous characters.
|
|
2898
|
copying, carefully removing the leading extraneous characters.
|
|
2896
|
|
|
2899
|
|
|
2897
|
This extension identifies those starting characters and removes them
|
|
2900
|
This extension identifies those starting characters and removes them
|
|
2898
|
from the input automatically, so that one can paste multi-line examples
|
|
2901
|
from the input automatically, so that one can paste multi-line examples
|
|
2899
|
directly into IPython, saving a lot of time. Please look at the file
|
|
2902
|
directly into IPython, saving a lot of time. Please look at the file
|
|
2900
|
InterpreterPasteInput.py in the IPython/Extensions directory for details
|
|
2903
|
InterpreterPasteInput.py in the IPython/Extensions directory for details
|
|
2901
|
on how this is done.
|
|
2904
|
on how this is done.
|
|
2902
|
|
|
2905
|
|
|
2903
|
IPython comes with a special profile enabling this feature, called
|
|
2906
|
IPython comes with a special profile enabling this feature, called
|
|
2904
|
tutorial. Simply start IPython via 'ipython -p tutorial' and the feature
|
|
2907
|
tutorial. Simply start IPython via 'ipython -p tutorial' and the feature
|
|
2905
|
will be available. In a normal IPython session you can activate the
|
|
2908
|
will be available. In a normal IPython session you can activate the
|
|
2906
|
feature by importing the corresponding module with:
|
|
2909
|
feature by importing the corresponding module with:
|
|
2907
|
In [1]: import IPython.Extensions.InterpreterPasteInput
|
|
2910
|
In [1]: import IPython.Extensions.InterpreterPasteInput
|
|
2908
|
|
|
2911
|
|
|
2909
|
The following is a 'screenshot' of how things work when this extension
|
|
2912
|
The following is a 'screenshot' of how things work when this extension
|
|
2910
|
is on, copying an example from the standard tutorial::
|
|
2913
|
is on, copying an example from the standard tutorial::
|
|
2911
|
|
|
2914
|
|
|
2912
|
IPython profile: tutorial
|
|
2915
|
IPython profile: tutorial
|
|
2913
|
|
|
2916
|
|
|
2914
|
*** Pasting of code with ">>>" or "..." has been enabled.
|
|
2917
|
*** Pasting of code with ">>>" or "..." has been enabled.
|
|
2915
|
|
|
2918
|
|
|
2916
|
In [1]: >>> def fib2(n): # return Fibonacci series up to n
|
|
2919
|
In [1]: >>> def fib2(n): # return Fibonacci series up to n
|
|
2917
|
...: ... """Return a list containing the Fibonacci series up to
|
|
2920
|
...: ... """Return a list containing the Fibonacci series up to
|
|
2918
|
n."""
|
|
2921
|
n."""
|
|
2919
|
...: ... result = []
|
|
2922
|
...: ... result = []
|
|
2920
|
...: ... a, b = 0, 1
|
|
2923
|
...: ... a, b = 0, 1
|
|
2921
|
...: ... while b < n:
|
|
2924
|
...: ... while b < n:
|
|
2922
|
...: ... result.append(b) # see below
|
|
2925
|
...: ... result.append(b) # see below
|
|
2923
|
...: ... a, b = b, a+b
|
|
2926
|
...: ... a, b = b, a+b
|
|
2924
|
...: ... return result
|
|
2927
|
...: ... return result
|
|
2925
|
...:
|
|
2928
|
...:
|
|
2926
|
|
|
2929
|
|
|
2927
|
In [2]: fib2(10)
|
|
2930
|
In [2]: fib2(10)
|
|
2928
|
Out[2]: [1, 1, 2, 3, 5, 8]
|
|
2931
|
Out[2]: [1, 1, 2, 3, 5, 8]
|
|
2929
|
|
|
2932
|
|
|
2930
|
Note that as currently written, this extension does not recognize
|
|
2933
|
Note that as currently written, this extension does not recognize
|
|
2931
|
IPython's prompts for pasting. Those are more complicated, since the
|
|
2934
|
IPython's prompts for pasting. Those are more complicated, since the
|
|
2932
|
user can change them very easily, they involve numbers and can vary in
|
|
2935
|
user can change them very easily, they involve numbers and can vary in
|
|
2933
|
length. One could however extract all the relevant information from the
|
|
2936
|
length. One could however extract all the relevant information from the
|
|
2934
|
IPython instance and build an appropriate regular expression. This is
|
|
2937
|
IPython instance and build an appropriate regular expression. This is
|
|
2935
|
left as an exercise for the reader.
|
|
2938
|
left as an exercise for the reader.
|
|
2936
|
|
|
2939
|
|
|
2937
|
|
|
2940
|
|
|
2938
|
Input of physical quantities with units
|
|
2941
|
Input of physical quantities with units
|
|
2939
|
---------------------------------------
|
|
2942
|
---------------------------------------
|
|
2940
|
|
|
2943
|
|
|
2941
|
The module PhysicalQInput allows a simplified form of input for physical
|
|
2944
|
The module PhysicalQInput allows a simplified form of input for physical
|
|
2942
|
quantities with units. This file is meant to be used in conjunction with
|
|
2945
|
quantities with units. This file is meant to be used in conjunction with
|
|
2943
|
the PhysicalQInteractive module (in the same directory) and
|
|
2946
|
the PhysicalQInteractive module (in the same directory) and
|
|
2944
|
Physics.PhysicalQuantities from Konrad Hinsen's ScientificPython
|
|
2947
|
Physics.PhysicalQuantities from Konrad Hinsen's ScientificPython
|
|
2945
|
(http://dirac.cnrs-orleans.fr/ScientificPython/).
|
|
2948
|
(http://dirac.cnrs-orleans.fr/ScientificPython/).
|
|
2946
|
|
|
2949
|
|
|
2947
|
The Physics.PhysicalQuantities module defines PhysicalQuantity objects,
|
|
2950
|
The Physics.PhysicalQuantities module defines PhysicalQuantity objects,
|
|
2948
|
but these must be declared as instances of a class. For example, to
|
|
2951
|
but these must be declared as instances of a class. For example, to
|
|
2949
|
define v as a velocity of 3 m/s, normally you would write::
|
|
2952
|
define v as a velocity of 3 m/s, normally you would write::
|
|
2950
|
|
|
2953
|
|
|
2951
|
In [1]: v = PhysicalQuantity(3,'m/s')
|
|
2954
|
In [1]: v = PhysicalQuantity(3,'m/s')
|
|
2952
|
|
|
2955
|
|
|
2953
|
Using the PhysicalQ_Input extension this can be input instead as:
|
|
2956
|
Using the PhysicalQ_Input extension this can be input instead as:
|
|
2954
|
In [1]: v = 3 m/s
|
|
2957
|
In [1]: v = 3 m/s
|
|
2955
|
which is much more convenient for interactive use (even though it is
|
|
2958
|
which is much more convenient for interactive use (even though it is
|
|
2956
|
blatantly invalid Python syntax).
|
|
2959
|
blatantly invalid Python syntax).
|
|
2957
|
|
|
2960
|
|
|
2958
|
The physics profile supplied with IPython (enabled via 'ipython -p
|
|
2961
|
The physics profile supplied with IPython (enabled via 'ipython -p
|
|
2959
|
physics') uses these extensions, which you can also activate with:
|
|
2962
|
physics') uses these extensions, which you can also activate with:
|
|
2960
|
|
|
2963
|
|
|
2961
|
from math import * # math MUST be imported BEFORE PhysicalQInteractive
|
|
2964
|
from math import * # math MUST be imported BEFORE PhysicalQInteractive
|
|
2962
|
from IPython.Extensions.PhysicalQInteractive import *
|
|
2965
|
from IPython.Extensions.PhysicalQInteractive import *
|
|
2963
|
import IPython.Extensions.PhysicalQInput
|
|
2966
|
import IPython.Extensions.PhysicalQInput
|
|
2964
|
|
|
2967
|
|
|
2965
|
|
|
2968
|
|
|
2966
|
Threading support
|
|
2969
|
Threading support
|
|
2967
|
=================
|
|
2970
|
=================
|
|
2968
|
|
|
2971
|
|
|
2969
|
WARNING: The threading support is still somewhat experimental, and it
|
|
2972
|
WARNING: The threading support is still somewhat experimental, and it
|
|
2970
|
has only seen reasonable testing under Linux. Threaded code is
|
|
2973
|
has only seen reasonable testing under Linux. Threaded code is
|
|
2971
|
particularly tricky to debug, and it tends to show extremely
|
|
2974
|
particularly tricky to debug, and it tends to show extremely
|
|
2972
|
platform-dependent behavior. Since I only have access to Linux machines,
|
|
2975
|
platform-dependent behavior. Since I only have access to Linux machines,
|
|
2973
|
I will have to rely on user's experiences and assistance for this area
|
|
2976
|
I will have to rely on user's experiences and assistance for this area
|
|
2974
|
of IPython to improve under other platforms.
|
|
2977
|
of IPython to improve under other platforms.
|
|
2975
|
|
|
2978
|
|
|
2976
|
IPython, via the -gthread , -qthread, -q4thread and -wthread options
|
|
2979
|
IPython, via the -gthread , -qthread, -q4thread and -wthread options
|
|
2977
|
(described in Sec. `Threading options`_), can run in
|
|
2980
|
(described in Sec. `Threading options`_), can run in
|
|
2978
|
multithreaded mode to support pyGTK, Qt3, Qt4 and WXPython applications
|
|
2981
|
multithreaded mode to support pyGTK, Qt3, Qt4 and WXPython applications
|
|
2979
|
respectively. These GUI toolkits need to control the python main loop of
|
|
2982
|
respectively. These GUI toolkits need to control the python main loop of
|
|
2980
|
execution, so under a normal Python interpreter, starting a pyGTK, Qt3,
|
|
2983
|
execution, so under a normal Python interpreter, starting a pyGTK, Qt3,
|
|
2981
|
Qt4 or WXPython application will immediately freeze the shell.
|
|
2984
|
Qt4 or WXPython application will immediately freeze the shell.
|
|
2982
|
|
|
2985
|
|
|
2983
|
IPython, with one of these options (you can only use one at a time),
|
|
2986
|
IPython, with one of these options (you can only use one at a time),
|
|
2984
|
separates the graphical loop and IPython's code execution run into
|
|
2987
|
separates the graphical loop and IPython's code execution run into
|
|
2985
|
different threads. This allows you to test interactively (with %run, for
|
|
2988
|
different threads. This allows you to test interactively (with %run, for
|
|
2986
|
example) your GUI code without blocking.
|
|
2989
|
example) your GUI code without blocking.
|
|
2987
|
|
|
2990
|
|
|
2988
|
A nice mini-tutorial on using IPython along with the Qt Designer
|
|
2991
|
A nice mini-tutorial on using IPython along with the Qt Designer
|
|
2989
|
application is available at the SciPy wiki:
|
|
2992
|
application is available at the SciPy wiki:
|
|
2990
|
http://www.scipy.org/Cookbook/Matplotlib/Qt_with_IPython_and_Designer.
|
|
2993
|
http://www.scipy.org/Cookbook/Matplotlib/Qt_with_IPython_and_Designer.
|
|
2991
|
|
|
2994
|
|
|
2992
|
|
|
2995
|
|
|
2993
|
Tk issues
|
|
2996
|
Tk issues
|
|
2994
|
---------
|
|
2997
|
---------
|
|
2995
|
|
|
2998
|
|
|
2996
|
As indicated in Sec. `Threading options`_, a special -tk option is
|
|
2999
|
As indicated in Sec. `Threading options`_, a special -tk option is
|
|
2997
|
provided to try and allow Tk graphical applications to coexist
|
|
3000
|
provided to try and allow Tk graphical applications to coexist
|
|
2998
|
interactively with WX, Qt or GTK ones. Whether this works at all,
|
|
3001
|
interactively with WX, Qt or GTK ones. Whether this works at all,
|
|
2999
|
however, is very platform and configuration dependent. Please
|
|
3002
|
however, is very platform and configuration dependent. Please
|
|
3000
|
experiment with simple test cases before committing to using this
|
|
3003
|
experiment with simple test cases before committing to using this
|
|
3001
|
combination of Tk and GTK/Qt/WX threading in a production environment.
|
|
3004
|
combination of Tk and GTK/Qt/WX threading in a production environment.
|
|
3002
|
|
|
3005
|
|
|
3003
|
|
|
3006
|
|
|
3004
|
I/O pitfalls
|
|
3007
|
I/O pitfalls
|
|
3005
|
------------
|
|
3008
|
------------
|
|
3006
|
|
|
3009
|
|
|
3007
|
Be mindful that the Python interpreter switches between threads every
|
|
3010
|
Be mindful that the Python interpreter switches between threads every
|
|
3008
|
$N$ bytecodes, where the default value as of Python 2.3 is $N=100.$ This
|
|
3011
|
$N$ bytecodes, where the default value as of Python 2.3 is $N=100.$ This
|
|
3009
|
value can be read by using the sys.getcheckinterval() function, and it
|
|
3012
|
value can be read by using the sys.getcheckinterval() function, and it
|
|
3010
|
can be reset via sys.setcheckinterval(N). This switching of threads can
|
|
3013
|
can be reset via sys.setcheckinterval(N). This switching of threads can
|
|
3011
|
cause subtly confusing effects if one of your threads is doing file I/O.
|
|
3014
|
cause subtly confusing effects if one of your threads is doing file I/O.
|
|
3012
|
In text mode, most systems only flush file buffers when they encounter a
|
|
3015
|
In text mode, most systems only flush file buffers when they encounter a
|
|
3013
|
'\n'. An instruction as simple as::
|
|
3016
|
'\n'. An instruction as simple as::
|
|
3014
|
|
|
3017
|
|
|
3015
|
print >> filehandle, ''hello world''
|
|
3018
|
print >> filehandle, ''hello world''
|
|
3016
|
|
|
3019
|
|
|
3017
|
actually consists of several bytecodes, so it is possible that the
|
|
3020
|
actually consists of several bytecodes, so it is possible that the
|
|
3018
|
newline does not reach your file before the next thread switch.
|
|
3021
|
newline does not reach your file before the next thread switch.
|
|
3019
|
Similarly, if you are writing to a file in binary mode, the file won't
|
|
3022
|
Similarly, if you are writing to a file in binary mode, the file won't
|
|
3020
|
be flushed until the buffer fills, and your other thread may see
|
|
3023
|
be flushed until the buffer fills, and your other thread may see
|
|
3021
|
apparently truncated files.
|
|
3024
|
apparently truncated files.
|
|
3022
|
|
|
3025
|
|
|
3023
|
For this reason, if you are using IPython's thread support and have (for
|
|
3026
|
For this reason, if you are using IPython's thread support and have (for
|
|
3024
|
example) a GUI application which will read data generated by files
|
|
3027
|
example) a GUI application which will read data generated by files
|
|
3025
|
written to from the IPython thread, the safest approach is to open all
|
|
3028
|
written to from the IPython thread, the safest approach is to open all
|
|
3026
|
of your files in unbuffered mode (the third argument to the file/open
|
|
3029
|
of your files in unbuffered mode (the third argument to the file/open
|
|
3027
|
function is the buffering value)::
|
|
3030
|
function is the buffering value)::
|
|
3028
|
|
|
3031
|
|
|
3029
|
filehandle = open(filename,mode,0)
|
|
3032
|
filehandle = open(filename,mode,0)
|
|
3030
|
|
|
3033
|
|
|
3031
|
This is obviously a brute force way of avoiding race conditions with the
|
|
3034
|
This is obviously a brute force way of avoiding race conditions with the
|
|
3032
|
file buffering. If you want to do it cleanly, and you have a resource
|
|
3035
|
file buffering. If you want to do it cleanly, and you have a resource
|
|
3033
|
which is being shared by the interactive IPython loop and your GUI
|
|
3036
|
which is being shared by the interactive IPython loop and your GUI
|
|
3034
|
thread, you should really handle it with thread locking and
|
|
3037
|
thread, you should really handle it with thread locking and
|
|
3035
|
syncrhonization properties. The Python documentation discusses these.
|
|
3038
|
syncrhonization properties. The Python documentation discusses these.
|
|
3036
|
|
|
3039
|
|
|
3037
|
.. _Interactive demos:
|
|
3040
|
.. _interactive_demos:
|
|
3038
|
|
|
3041
|
|
|
3039
|
Interactive demos with IPython
|
|
3042
|
Interactive demos with IPython
|
|
3040
|
==============================
|
|
3043
|
==============================
|
|
3041
|
|
|
3044
|
|
|
3042
|
IPython ships with a basic system for running scripts interactively in
|
|
3045
|
IPython ships with a basic system for running scripts interactively in
|
|
3043
|
sections, useful when presenting code to audiences. A few tags embedded
|
|
3046
|
sections, useful when presenting code to audiences. A few tags embedded
|
|
3044
|
in comments (so that the script remains valid Python code) divide a file
|
|
3047
|
in comments (so that the script remains valid Python code) divide a file
|
|
3045
|
into separate blocks, and the demo can be run one block at a time, with
|
|
3048
|
into separate blocks, and the demo can be run one block at a time, with
|
|
3046
|
IPython printing (with syntax highlighting) the block before executing
|
|
3049
|
IPython printing (with syntax highlighting) the block before executing
|
|
3047
|
it, and returning to the interactive prompt after each block. The
|
|
3050
|
it, and returning to the interactive prompt after each block. The
|
|
3048
|
interactive namespace is updated after each block is run with the
|
|
3051
|
interactive namespace is updated after each block is run with the
|
|
3049
|
contents of the demo's namespace.
|
|
3052
|
contents of the demo's namespace.
|
|
3050
|
|
|
3053
|
|
|
3051
|
This allows you to show a piece of code, run it and then execute
|
|
3054
|
This allows you to show a piece of code, run it and then execute
|
|
3052
|
interactively commands based on the variables just created. Once you
|
|
3055
|
interactively commands based on the variables just created. Once you
|
|
3053
|
want to continue, you simply execute the next block of the demo. The
|
|
3056
|
want to continue, you simply execute the next block of the demo. The
|
|
3054
|
following listing shows the markup necessary for dividing a script into
|
|
3057
|
following listing shows the markup necessary for dividing a script into
|
|
3055
|
sections for execution as a demo::
|
|
3058
|
sections for execution as a demo::
|
|
3056
|
|
|
3059
|
|
|
3057
|
|
|
3060
|
|
|
3058
|
"""A simple interactive demo to illustrate the use of IPython's Demo class.
|
|
3061
|
"""A simple interactive demo to illustrate the use of IPython's Demo class.
|
|
3059
|
|
|
3062
|
|
|
3060
|
Any python script can be run as a demo, but that does little more than showing
|
|
3063
|
Any python script can be run as a demo, but that does little more than showing
|
|
3061
|
it on-screen, syntax-highlighted in one shot. If you add a little simple
|
|
3064
|
it on-screen, syntax-highlighted in one shot. If you add a little simple
|
|
3062
|
markup, you can stop at specified intervals and return to the ipython prompt,
|
|
3065
|
markup, you can stop at specified intervals and return to the ipython prompt,
|
|
3063
|
resuming execution later.
|
|
3066
|
resuming execution later.
|
|
3064
|
"""
|
|
3067
|
"""
|
|
3065
|
|
|
3068
|
|
|
3066
|
print 'Hello, welcome to an interactive IPython demo.'
|
|
3069
|
print 'Hello, welcome to an interactive IPython demo.'
|
|
3067
|
print 'Executing this block should require confirmation before proceeding,'
|
|
3070
|
print 'Executing this block should require confirmation before proceeding,'
|
|
3068
|
print 'unless auto_all has been set to true in the demo object'
|
|
3071
|
print 'unless auto_all has been set to true in the demo object'
|
|
3069
|
|
|
3072
|
|
|
3070
|
# The mark below defines a block boundary, which is a point where IPython will
|
|
3073
|
# The mark below defines a block boundary, which is a point where IPython will
|
|
3071
|
# stop execution and return to the interactive prompt.
|
|
3074
|
# stop execution and return to the interactive prompt.
|
|
3072
|
# Note that in actual interactive execution,
|
|
3075
|
# Note that in actual interactive execution,
|
|
3073
|
# <demo> --- stop ---
|
|
3076
|
# <demo> --- stop ---
|
|
3074
|
|
|
3077
|
|
|
3075
|
x = 1
|
|
3078
|
x = 1
|
|
3076
|
y = 2
|
|
3079
|
y = 2
|
|
3077
|
|
|
3080
|
|
|
3078
|
# <demo> --- stop ---
|
|
3081
|
# <demo> --- stop ---
|
|
3079
|
|
|
3082
|
|
|
3080
|
# the mark below makes this block as silent
|
|
3083
|
# the mark below makes this block as silent
|
|
3081
|
# <demo> silent
|
|
3084
|
# <demo> silent
|
|
3082
|
|
|
3085
|
|
|
3083
|
print 'This is a silent block, which gets executed but not printed.'
|
|
3086
|
print 'This is a silent block, which gets executed but not printed.'
|
|
3084
|
|
|
3087
|
|
|
3085
|
# <demo> --- stop ---
|
|
3088
|
# <demo> --- stop ---
|
|
3086
|
# <demo> auto
|
|
3089
|
# <demo> auto
|
|
3087
|
print 'This is an automatic block.'
|
|
3090
|
print 'This is an automatic block.'
|
|
3088
|
print 'It is executed without asking for confirmation, but printed.'
|
|
3091
|
print 'It is executed without asking for confirmation, but printed.'
|
|
3089
|
z = x+y
|
|
3092
|
z = x+y
|
|
3090
|
|
|
3093
|
|
|
3091
|
print 'z=',x
|
|
3094
|
print 'z=',x
|
|
3092
|
|
|
3095
|
|
|
3093
|
# <demo> --- stop ---
|
|
3096
|
# <demo> --- stop ---
|
|
3094
|
# This is just another normal block.
|
|
3097
|
# This is just another normal block.
|
|
3095
|
print 'z is now:', z
|
|
3098
|
print 'z is now:', z
|
|
3096
|
|
|
3099
|
|
|
3097
|
print 'bye!'
|
|
3100
|
print 'bye!'
|
|
3098
|
|
|
3101
|
|
|
3099
|
In order to run a file as a demo, you must first make a Demo object out
|
|
3102
|
In order to run a file as a demo, you must first make a Demo object out
|
|
3100
|
of it. If the file is named myscript.py, the following code will make a
|
|
3103
|
of it. If the file is named myscript.py, the following code will make a
|
|
3101
|
demo::
|
|
3104
|
demo::
|
|
3102
|
|
|
3105
|
|
|
3103
|
from IPython.demo import Demo
|
|
3106
|
from IPython.demo import Demo
|
|
3104
|
|
|
3107
|
|
|
3105
|
mydemo = Demo('myscript.py')
|
|
3108
|
mydemo = Demo('myscript.py')
|
|
3106
|
|
|
3109
|
|
|
3107
|
This creates the mydemo object, whose blocks you run one at a time by
|
|
3110
|
This creates the mydemo object, whose blocks you run one at a time by
|
|
3108
|
simply calling the object with no arguments. If you have autocall active
|
|
3111
|
simply calling the object with no arguments. If you have autocall active
|
|
3109
|
in IPython (the default), all you need to do is type::
|
|
3112
|
in IPython (the default), all you need to do is type::
|
|
3110
|
|
|
3113
|
|
|
3111
|
mydemo
|
|
3114
|
mydemo
|
|
3112
|
|
|
3115
|
|
|
3113
|
and IPython will call it, executing each block. Demo objects can be
|
|
3116
|
and IPython will call it, executing each block. Demo objects can be
|
|
3114
|
restarted, you can move forward or back skipping blocks, re-execute the
|
|
3117
|
restarted, you can move forward or back skipping blocks, re-execute the
|
|
3115
|
last block, etc. Simply use the Tab key on a demo object to see its
|
|
3118
|
last block, etc. Simply use the Tab key on a demo object to see its
|
|
3116
|
methods, and call '?' on them to see their docstrings for more usage
|
|
3119
|
methods, and call '?' on them to see their docstrings for more usage
|
|
3117
|
details. In addition, the demo module itself contains a comprehensive
|
|
3120
|
details. In addition, the demo module itself contains a comprehensive
|
|
3118
|
docstring, which you can access via::
|
|
3121
|
docstring, which you can access via::
|
|
3119
|
|
|
3122
|
|
|
3120
|
from IPython import demo
|
|
3123
|
from IPython import demo
|
|
3121
|
|
|
3124
|
|
|
3122
|
demo?
|
|
3125
|
demo?
|
|
3123
|
|
|
3126
|
|
|
3124
|
Limitations: It is important to note that these demos are limited to
|
|
3127
|
Limitations: It is important to note that these demos are limited to
|
|
3125
|
fairly simple uses. In particular, you can not put division marks in
|
|
3128
|
fairly simple uses. In particular, you can not put division marks in
|
|
3126
|
indented code (loops, if statements, function definitions, etc.)
|
|
3129
|
indented code (loops, if statements, function definitions, etc.)
|
|
3127
|
Supporting something like this would basically require tracking the
|
|
3130
|
Supporting something like this would basically require tracking the
|
|
3128
|
internal execution state of the Python interpreter, so only top-level
|
|
3131
|
internal execution state of the Python interpreter, so only top-level
|
|
3129
|
divisions are allowed. If you want to be able to open an IPython
|
|
3132
|
divisions are allowed. If you want to be able to open an IPython
|
|
3130
|
instance at an arbitrary point in a program, you can use IPython's
|
|
3133
|
instance at an arbitrary point in a program, you can use IPython's
|
|
3131
|
embedding facilities, described in detail in Sec. 9
|
|
3134
|
embedding facilities, described in detail in Sec. 9
|
|
3132
|
|
|
3135
|
|
|
3133
|
|
|
3136
|
|
|
3134
|
.. _Matplotlib support:
|
|
3137
|
.. _Matplotlib support:
|
|
3135
|
|
|
3138
|
|
|
3136
|
Plotting with matplotlib
|
|
3139
|
Plotting with matplotlib
|
|
3137
|
========================
|
|
3140
|
========================
|
|
3138
|
|
|
3141
|
|
|
3139
|
The matplotlib library (http://matplotlib.sourceforge.net
|
|
3142
|
The matplotlib library (http://matplotlib.sourceforge.net
|
|
3140
|
http://matplotlib.sourceforge.net) provides high quality 2D plotting for
|
|
3143
|
http://matplotlib.sourceforge.net) provides high quality 2D plotting for
|
|
3141
|
Python. Matplotlib can produce plots on screen using a variety of GUI
|
|
3144
|
Python. Matplotlib can produce plots on screen using a variety of GUI
|
|
3142
|
toolkits, including Tk, GTK and WXPython. It also provides a number of
|
|
3145
|
toolkits, including Tk, GTK and WXPython. It also provides a number of
|
|
3143
|
commands useful for scientific computing, all with a syntax compatible
|
|
3146
|
commands useful for scientific computing, all with a syntax compatible
|
|
3144
|
with that of the popular Matlab program.
|
|
3147
|
with that of the popular Matlab program.
|
|
3145
|
|
|
3148
|
|
|
3146
|
IPython accepts the special option -pylab (Sec. `Command line
|
|
3149
|
IPython accepts the special option -pylab (see :ref:`here
|
|
3147
|
options`_). This configures it to support matplotlib, honoring the
|
|
3150
|
<command_line_options>`). This configures it to support matplotlib, honoring
|
|
3148
|
settings in the .matplotlibrc file. IPython will detect the user's
|
|
3151
|
the settings in the .matplotlibrc file. IPython will detect the user's choice
|
|
3149
|
choice of matplotlib GUI backend, and automatically select the proper
|
|
3152
|
of matplotlib GUI backend, and automatically select the proper threading model
|
|
3150
|
threading model to prevent blocking. It also sets matplotlib in
|
|
3153
|
to prevent blocking. It also sets matplotlib in interactive mode and modifies
|
|
3151
|
interactive mode and modifies %run slightly, so that any
|
|
3154
|
%run slightly, so that any matplotlib-based script can be executed using %run
|
|
3152
|
matplotlib-based script can be executed using %run and the final
|
|
3155
|
and the final show() command does not block the interactive shell.
|
|
3153
|
show() command does not block the interactive shell.
|
|
3156
|
|
|
3154
|
|
|
3157
|
The -pylab option must be given first in order for IPython to configure its
|
|
3155
|
The -pylab option must be given first in order for IPython to
|
|
3158
|
threading mode. However, you can still issue other options afterwards. This
|
|
3156
|
configure its threading mode. However, you can still issue other
|
|
3159
|
allows you to have a matplotlib-based environment customized with additional
|
|
3157
|
options afterwards. This allows you to have a matplotlib-based
|
|
3160
|
modules using the standard IPython profile mechanism (see :ref:`here
|
|
3158
|
environment customized with additional modules using the standard
|
|
3161
|
<profiles>`): ``ipython -pylab -p myprofile`` will load the profile defined in
|
|
3159
|
IPython profile mechanism (Sec. Profiles_): ''ipython -pylab -p
|
|
3162
|
ipythonrc-myprofile after configuring matplotlib.
|
|
3160
|
myprofile'' will load the profile defined in ipythonrc-myprofile after
|
|
|
|
|
3161
|
configuring matplotlib.
|
|
|
|
|
3162
|
|
|
|
|
|
3163
|
|
|
|
|