Not sure about keeping operators as a map->function (it might be cleaner/simpler just to have a switch).

operators = ‘+-/*’

def get_input():
input = raw_input(“input: “)
return input

def number(num):
if ‘.’ in num:
return float(num)
elif num not in operators:
return int(num)

def parse_input(text):
text = text.split()
stack = []
for x in text:
if x.isdigit() or number(x):
stack.insert(0, number(x))
elif x in operators:
stack.insert(0, operate(stack, x))
return stack

def operate(nums, operator):
b = nums.pop(0)
a = nums.pop(0)
if operator == ‘+’:
return a + b
elif operator == ‘-’:
return a – b
elif operator == ‘/’:
return a / b
else: return a * b

if __name__ == ‘__main__’:
answer = parse_input(‘get_input’)[0]
print answer

#!/usr/bin/env python

import operator
import sys
from numbers import Number

_OPERATORS = {
    '+': operator.add,
    '-': operator.sub,
    '*': operator.mul,
    '/': operator.div
}

class ParseException(Exception):
    pass

def _to_number(string):
    '''Accepts a string or and returns a number represented by that string.
    If a number is passed, that number is returned intact.'''
    if isinstance(string, Number):
        return string
    try:
        return int(string)
    except ValueError:
        return float(string)

def _calculate(stack):
    '''Takes a list representing an expression stack and solves the first expression found.
    Changes the list in place.'''
    op = None
    for op_index in xrange(len(stack)):
        if stack[op_index] in _OPERATORS.keys():
            op = stack[op_index]
            break
    if op is None or op_index < 2:
        return
    left_operand, right_operand = stack[op_index - 2:op_index]
    try:
        left_operand = _to_number(left_operand)
        right_operand = _to_number(right_operand)
    except ValueError:
        raise ParseException('Unknown numbers')
    stack[op_index - 2] = _OPERATORS[op](left_operand, right_operand)
    stack[op_index - 1:] = stack[op_index + 1:]

def main():
    stack = []
    print 'RPN calculator. Enter an empty line to quit.'
    while True:
        user_input = sys.stdin.readline().split()
        if not user_input:
            return
        stack.extend(user_input)
        old_len = len(stack)
        while True:
            try:
                _calculate(stack)
            except ParseException as e:
                print '{0}\nStack is cleared.'.format(e.message)
                stack = []
                break
            if len(stack) == old_len:
                break
            old_len = len(stack)
        print '> {0}'.format(' '.join(str(n) for n in stack))

if __name__ == '__main__':
    main()

var RPN = {
	ops: {
		'+': function(a, b) { return +a + +b; },
		'-': function(a, b) { return a - b; },
		'*': function(a, b) { return a * b; },
		'/': function(a, b) { return a / b; },
		'**': Math.pow
	},
	stack: [],
	eval: function(line)
	{
		var tokens = line.split(/\s+/);
		for (var i = 0; i < tokens.length; i++) {
			var t = tokens[i];

			var op = this.ops[t];

			if ( ! op ) {
				this.error(isNaN(Number(t)), 'Illegal number.');

				this.stack.push(t);
				continue;
			}

			this.error(this.stack.length  ');
	},
	input: function()
	{
		return WScript.StdIn.ReadLine();
	},
	alert: function(msg)
	{
		WScript.StdOut.WriteLine(msg.join('\n'));
	},
	error: function(cond, msg)
	{
		if ( ! cond ) {
			return;
		}
		throw new Error(msg);
	},
	quit: function()
	{
		WScript.Quit();
	}
};

while ( true ) {
	RPN.prompt();
	RPN.alert(RPN.eval(RPN.input()));
}