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.

A.1 Line Editing

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.

A.2 History Substitution

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.

A.3 Key Bindings

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

set option-name value

For example:

# I prefer vi-style editing:
set editing-mode vi

# Edit using a single line:
set horizontal-scroll-mode On

# 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:^A.1

import rlcompleter, readline
readline.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 environments. 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=/max/home/itamar/.pystartup" in bash.
#
# Note that PYTHONSTARTUP does *not* expand "~", so you have to put in the
# full path to your home directory.

import atexit
import os
import readline
import rlcompleter

historyPath = os.path.expanduser("~/.pyhistory")

def save_history(historyPath=historyPath):
    import readline
    readline.write_history_file(historyPath)

if os.path.exists(historyPath):
    readline.read_history_file(historyPath)

atexit.register(save_history)
del os, atexit, readline, rlcompleter, save_history, historyPath

A.4 Commentary

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.

Footnotes

... file:^A.1

Python will execute the contents of a file identified by the
PYTHONSTARTUP environment variable when you start an
interactive interpreter.