array, a better shell

[bearophileHUGS at lycos.com]

For array.array "B" means unsigned char, and such arrays accept to be
initialized from (str) strings too, this is quite useful:

>>> from array import array
>>> a = array("B", "hello")

But it seems such capability isn't shared with the append:

>>> a.extend("hello")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: an integer is required

------------------------

I like a lot the Python shell, it helps me in many different
situations. I have tried some Python shells:
- the vanilla one from DOS
- the one from ActivePython IDE
- the one from SPE
- ipython from a DOS shell

But none of them has what I'd like.
ipython tries to be a better shell, but I don't want more complexity
and more commands/tricks to remember, I want something more
interactive, that's simpler and more powerful to use, and not something
(much) more complex. Much less things, but the important ones.
Beside the vanilla one, I end using the SPE one (because it has colours
on Windows too, and it allows you to paste a piece of interactive shell
with the leading >>>, SPE removes them automatically. This is very
handy).

I have also used the shell of Mathematica. It's quite powerful and it
can show graphics too inlined, but globally I don't like it fully
because it makes editing small programs a pain (for me). Even if I
globally don't like the Mathematica shell, it has a capability that I'd
like to have in a basic Python shell too.
(NOTE: often when dealing with GUI subtle details make a *big*
difference, and it's not easy to use words to describe such interaction
details.)
This Mathematica shell allows you to edit small programs (like 1-15
lines of code) as input blocks, and later you can click on them and
edit them. When you press shift-enter inside a block, that small
program runs and its output goes just below it (and not at the end of
the current shell log). All the Input Blocks can be edited and run
again like that (an Input/Output number tag helps to keep things sorted
enough). So it's a cross between a normal stupid shell that's
essentially an I/O + visual log, and a bare-bone text editor that
allows you to edit one script and run it too.
Such capability probably needs a Tk/Wx/Gtk window...

-------

(Such interactive sessions can be saved too, and loaded again (they
become complex documents), but such ability isn't necessary into a
bare-bone shell that I am describing now. I am describing something as
simple as possible).

Beside that (new) basic shell capability  I think I can appreciate two
other capabilities:
- Automatically saves the last 20 MBytes of textual input/output log
inside a "queue" file. Material older than the last 20 MB is removed
from the top.
- Ability to break the computation (or the printing of VERY long
things!) without exiting the shell and the kernel (this is from
Mathematica too).

Bye,
bearophile