Python Prefix Notation Evaluater

Only addressing your last point about the layout of operatorTable, i would use 4 space indentation as according to PEP8-indentation.

operatorTable = { 
    "+": Operator(2, lambda a,b: a+b),
    "-": Operator(2, lambda a,b: a-b),
    "/": Operator(2, lambda a,b: a/b),
    "*": Operator(2, lambda a,b: a*b),
    "<": Operator(2, lambda a,b: a<b),
    ">": Operator(2, lambda a,b: a>b),
    "_": Operator(1, lambda a: -a),
    "p": Operator(0, lambda: math.pi),
    "e": Operator(0, lambda: math.e),
}

Also note the comma after the last item. This has a small advantage when you use a source control system, when another item is added after the last item only the new line will show up in a diff and not the previous line which only has a comma added.

General comment

Your code is well organised and easy to follow. Still it would be nice to add a bit of documentation, for instance to describe what the functions return. Also, you could try to follow PEP8, the Style Guide for Python Code, for instance, by using snake_case rather than camelCase. Also, I'd try to align the content of operatorTable to get something like:

operatorTable = {
    "+": Operator(2, lambda a,b: a+b),
    "-": Operator(2, lambda a,b: a-b),
    "/": Operator(2, lambda a,b: a/b),
    "*": Operator(2, lambda a,b: a*b),
    "<": Operator(2, lambda a,b: a<b),
    ">": Operator(2, lambda a,b: a>b),
    "_": Operator(1, lambda a: -a),
    "p": Operator(0, lambda: math.pi),
    "e": Operator(0, lambda: math.e)
}

The Operator class

I quite like the Operator class and the way you use it to map characters to function objects.

However, the various lambda functions you are defining are not need as you could use functions from the operator module.

Also, you could define a class to handle the special case of constants to avoid defining dummy functions.

You'd get something like:

class Operator:
    def __init__(self, arity, function):
        self.arity = arity
        self.function = function

    def __call__(self, *args):
        assert(len(args) == self.arity)
        return self.function(*args)

class Constant:
    def __init__(self, value):
        self.value = value
        self.arity = 0

    def __call__(self, *args):
        assert(len(args) == self.arity)
        return self.value

operatorTable = {
    "+": Operator(2, operator.add),
    "-": Operator(2, operator.sub),
    "/": Operator(2, operator.truediv),
    "*": Operator(2, operator.mul),
    "<": Operator(2, operator.lt),
    ">": Operator(2, operator.gt),
    "_": Operator(1, operator.neg),
    "p": Constant(math.pi),
    "e": Constant(math.e),
}

Parsing

Instead of relying on a recursion function progressing one digit at a time, you could split your input into tokens (numbers and operators in your case) and then iterate over the different tokens.

I'd suggest something like (but it can probably be done in a better way):

def tokenize(string):
    while string:
        c = string[0]
        if c in operatorTable:
            yield operatorTable[c]
            string = string[1:]
        elif c in whitespaces:
            string = string[1:]
        else:
            match = re.match("^\d+", string)
            if match:
                yield Constant(int(match.group(0)))
                string = string[match.end():]
            else:
                raise ValueError("Could not parse " + string)

To be continued.