Navigation

Some versions of the Python interpreter support editing of the current input
line and history substitution, similar to facilities found in the Korn shell and
the GNU Bash shell. This is implemented using the GNU Readline library,
which supports Emacs-style and vi-style editing. This library has its own
documentation which I won’t duplicate here; however, the basics are easily
explained. The interactive editing and history described here are optionally
available in the Unix and Cygwin versions of the interpreter.

This chapter does not document the editing facilities of Mark Hammond’s
PythonWin package or the Tk-based environment, IDLE, distributed with Python.
The command line history recall which operates within DOS boxes on NT and some
other DOS and Windows flavors is yet another beast.

If supported, input line editing is active whenever the interpreter prints a
primary or secondary prompt. The current line can be edited using the
conventional Emacs control characters. The most important of these are:
C-A (Control-A) moves the cursor to the beginning of the line, C-E
to the end, C-B moves it one position to the left, C-F to the
right. Backspace erases the character to the left of the cursor, C-D the
character to its right. C-K kills (erases) the rest of the line to the
right of the cursor, C-Y yanks back the last killed string.
C-underscore undoes the last change you made; it can be repeated for
cumulative effect.

History substitution works as follows. All non-empty input lines issued are
saved in a history buffer, and when a new prompt is given you are positioned on
a new line at the bottom of this buffer. C-P moves one line up (back) in
the history buffer, C-N moves one down. Any line in the history buffer
can be edited; an asterisk appears in front of the prompt to mark a line as
modified. Pressing the Return key passes the current line to the
interpreter. C-R starts an incremental reverse search; C-S starts
a forward search.

The key bindings and some other parameters of the Readline library can be
customized by placing commands in an initialization file called
~/.inputrc. Key bindings have the form

key-name:function-name

or

"string":function-name

and options can be set with

setoption-namevalue

For example:

# I prefer vi-style editing:setediting-modevi# Edit using a single line:sethorizontal-scroll-modeOn# Rebind some keys:Meta-h:backward-kill-word"\C-u":universal-argument"\C-x\C-r":re-read-init-file

Note that the default binding for Tab in Python is to insert a Tab
character instead of Readline’s default filename completion function. If you
insist, you can override this by putting

Tab:complete

in your ~/.inputrc. (Of course, this makes it harder to type indented
continuation lines if you’re accustomed to using Tab for that purpose.)

Automatic completion of variable and module names is optionally available. To
enable it in the interpreter’s interactive mode, add the following to your
startup file: [1]

importrlcompleter,readlinereadline.parse_and_bind('tab: complete')

This binds the Tab key to the completion function, so hitting the
Tab key twice suggests completions; it looks at Python statement names,
the current local variables, and the available module names. For dotted
expressions such as string.a, it will evaluate the expression up to the
final '.' and then suggest completions from the attributes of the resulting
object. Note that this may execute application-defined code if an object with a
__getattr__() method is part of the expression.

A more capable startup file might look like this example. Note that this
deletes the names it creates once they are no longer needed; this is done since
the startup file is executed in the same namespace as the interactive commands,
and removing the names avoids creating side effects in the interactive
environment. You may find it convenient to keep some of the imported modules,
such as os, which turn out to be needed in most sessions with the
interpreter.

# Add auto-completion and a stored history file of commands to your Python# interactive interpreter. Requires Python 2.0+, readline. Autocomplete is# bound to the Esc key by default (you can change it - see readline docs).## Store the file in ~/.pystartup, and set an environment variable to point# to it: "export PYTHONSTARTUP=~/.pystartup" in bash.importatexitimportosimportreadlineimportrlcompleterhistoryPath=os.path.expanduser("~/.pyhistory")defsave_history(historyPath=historyPath):importreadlinereadline.write_history_file(historyPath)ifos.path.exists(historyPath):readline.read_history_file(historyPath)atexit.register(save_history)delos,atexit,readline,rlcompleter,save_history,historyPath

This facility is an enormous step forward compared to earlier versions of the
interpreter; however, some wishes are left: It would be nice if the proper
indentation were suggested on continuation lines (the parser knows if an indent
token is required next). The completion mechanism might use the interpreter’s
symbol table. A command to check (or even suggest) matching parentheses,
quotes, etc., would also be useful.

One alternative enhanced interactive interpreter that has been around for quite
some time is IPython, which features tab completion, object exploration and
advanced history management. It can also be thoroughly customized and embedded
into other applications. Another similar enhanced interactive environment is
bpython.

Python will execute the contents of a file identified by the
PYTHONSTARTUP environment variable when you start an interactive
interpreter. To customize Python even for non-interactive mode, see
The Customization Modules.