I love the command line more than any graphic interface. I want to type commands, not move graphics around on a screen. Working through my keyboard is faster than clicking for me, and what I do seems more real. I don't know what it is that makes the keyboard seem more real than icons in a window. They're both abstractions, different ways of interacting with a a flow of bits and bytes. Maybe I was brainwashed from my early exposure to Unix.
Moving from Perl to Python, Python's intaractive prompt caught my attention right away. Demonstrating Python to my co-workers, I wowed them by creating Tk applications line by line. It was a demonstartion of prompt over GUI. Call it lexokinesis. Surely, creating an interface with a visual toolkit would be as easy or easier. You could draw one picture instead of writing a thousand words. Maybe it was our shared respect for the command line that made this ability seem useful in some way. As fledgling programmers, we liked that we could see more clearly what was going on.
The prompt very useful when learning Python. You enter commands and you get immediate feedback. I like that better than typing everything in at once then trying to run it--or more likely, trying to figure out why it didn't run. Using the prompt you explore as you go. When I was first learning Python, I even considered using it as my shell prompt. I eventually decided it took too much typing and gave up the idea. I must not have been inspired enough, or lazy enough. Nathan Gray was.
Gray developed LazyPython and deep_reload, tools that make the interactive prompt easier to use. LazyPython provides automatic quoting, parenning, and shell escapes. With the quoting enhancement a function or method call typed like this:
>>> ,func arg1 arg2 arg3
>>> func("arg1", "arg2", "arg3")
When used as the first character on your prompt line, that little comma lets Python know to take what follows as a function and its arguments. It adds the parentheses and quotes for you.
Similarly, you can add parentheses without the quotes using "/"
>>> /func arg1 arg2 arg3
>>> func(arg1, arg2, arg3)
or a simple
Some common functions, like
cp are automatically quoted so you
don't even have to type a ",". You can add your own favorite
functions to the list. Lazy Python also makes it easy to invoke a
system command. Called shell escapes, you perform one by prepending
your command with a "!".
Related to LazyPython, the deep_reload module is a recursive drop-in replacement for the reload command. It reloads all the modules a given module imports. This can be useful when you want to reload your entire project at once instead of one module at a time. More lazyness.
Enhancing the Python prompt is nothing new. Janko Hauser wrote an
enhanced interactive Python prompt called IPP.
Like LazyPython, IPP has shell escapes invoked with "!". IPP maintains
a prompt history that you can incrementally search by typing ctrl-r.
Just type in the letters of what you are looking for, and ipp will
search your command history for them. It has tab completion. Tabbing
in the middle of a command brings up a list of possible completions.
IPP also adds a help system built on top of Jim Eggleston's
docreader program. You invoke it with "?". The help
system will search through external documentation as well as the
docstrings of imported modules. It is similar to
Like IPP but simpler, Robin Friedrich's interactive.py offers tab completion, a simple help system, and
convenience functions for common shell escapes. The program is meant
to be used as a Python startup file. When Python loads its interactive
prompt, it looks for a
variable. It will load and execute any file listed in that variable
before dropping you at the prompt.
Gray, following the lazy way, has built upon Robin Friedrich's
work. He enhanced Friedrichs interactive.py by adding LazyPython and
deep_reload to it and changing Friedrich's help function so it uses
pydoc. If you don't have LazyPython or deep_reload, the
startup file still works, but it's sweet to have them all working
Boosting the power of interactive Python further, Gray has written gracePlot, an interactive interface to the 2D plotting tool Grace. Gray has integrated gracePlot with Numerical Python, and turned this C plotting package into a scientific exploration dream tool. You can make changes to the plot on the fly. You can even plot live data as it arrives.
It all adds up to Python power at the keyboard. I haven't given up on my BASH shell yet, but these tools have made playing at the interactive Python prompt much more fun, even when manipulating graphic applications. With gracePlot's interactive enhancements, Grace is a visualization tool with strong educational and scientific applications. Best of all, these tools have given me more opportunities to make my co-workers say, "wow!"
Stephen Figgins administrates Linux servers for Sunflower Broadband, a cable company.
Read more Python News columns.
Return to the Python DevCenter.