我的后缀计算器有多个错误

Question

Thanks to the wonderful users of StackOverflow, I have finally got my postfix calculator at least partially working. However, I am still running into multiple issues.

1.) I have edited the code a thousand times with this:

f = open("expressions.txt")
l = f.readlines()

When I do this, I get a list of ['5 4 3 * 9 /n', ' 3 4 - 9 3 * /n']. I have tried to go through and string the list, I have tried to string the list beforehand, and I have even just assumed it was already a string. After that, I tried both split(' ') and split ('\\n') and replace (' ','') and replace('/n','') and absolutely nothing happens. The list looks exactly the same.

2.) For expressions in which the expression is "int int int int opr opr opr", the code works. However, in the case of "int int int opr int" or any other time where there is an operator between two integers, it miscalculates.

3.) And with the above problem, the program is supposed to raise an exception if it reads an infix expression such as 3 + 4. So how can I tell it /not/ to accept 3 + 4 unless it's already in an expression that's been verified as postfix such as 3 + 4 9 8 *.

from ArrayStack import *

numbers = Stack()
operators = Stack()

def main():
    h = 0
    i = 0
    expression = str(input("Enter an expression: "))
    if not expression[0].isdigit():
        raise Exception("ERROR: " + expression + " is an invalid postfix expression.")
    for x in expression:
        if x.isalpha():
            raise Exception("ERROR: " + expression + " is an invalid postfix expression.")   
    if not expression[1].isdigit:
        raise Exception("ERROR: " + expression + " is an invalid postfix expression.")
    expression = expression.split(" ")
    for x in expression:
        if x.isdigit():
            numbers.push(x)
    while h != len(expression):
        if not expression[i-1].isdigit():
            operators.push(expression[i-1])
        i -=1
        h +=1
    print(numbers.data)
    print(operators.data)
    if len(numbers) == 2:
        first = numbers.pop()
        second = numbers.pop()
        check = operators.pop()
        if check == "+":
            temp = int(second) + int(first)
            numbers.push(temp)
        elif check == "-":
            temp = int(second) - int(first)
            numbers.push(temp)
        elif check == "/":
            temp = int(second) / int(first)
            numbers.push(temp)
        elif check == "*":
            temp = int(second) * int(first)
            numbers.push(temp)
        print("Answer:", numbers.data[0])
    while len(numbers) > 2:
        first = numbers.pop()
        second = numbers.pop()
        check = operators.pop()
        if check == "+":
            temp = int(second) + int(first)
            numbers.push(temp)
        elif check == "-":
            temp = int(second) - int(first)
            numbers.push(temp)
        elif check == "/":
            temp = int(first) / int(second)
            numbers.push(temp)
        elif check == "*":
            temp = int(second) * int(first)
            numbers.push(temp)
        if len(numbers) == 2:
            answer = numbers.pop()
            finalNum = numbers.pop()
            finalOpr = operators.pop()
            if finalOpr == "+":
                temp = int(answer) + int(finalNum)
                numbers.push(temp)
            elif finalOpr == "-":
                temp = int(finalNum) - int(answer)
                numbers.push(temp)
            elif finalOpr == "/":
                temp = int(finalNum) / int(answer)
                numbers.push(temp)
            elif finalOpr == "*":
                temp = int(answer) * int(finalNum)
                numbers.push(temp)
            print("Answer:", numbers.data[0])
            break

main()

Answer 1

1) Was already answered by @PadraicCunningham in a comment to the question:

lines = [line.strip().split() for line in source_file]

2) You can't separate the number and the operators into two separate stacks that way. An operator must operate on the two elements on the top of the stack at the time the operator is seen. The easiest way to achieve that is to leave out the operator stack and evaluate an operator immediately with the current number stack.

3) 3 + 4 9 8 * isn't a valid post fix expression. There is a 3 and then a + that just has one argument instead of the two it needs. Recognizing invalid expressions can be easily done by looking at the stack each time an operator is processed and after the whole expression is evaluated. Before each operator there have to be at least enough operands on the stack for that operator. After the expression is evaluated there should only be one value, the result, left on the stack.

So it boils down to: Just evaluate the postfix expression and raise an Exception if you encounter a problem on the way.

---

Update: A simple function to evaluate postfix notation:

from operator import add, sub, mul, div


OPERATOR2FUNC = {'+': add, '-': sub, '*': mul, '/': div}


def evaluate_postfix(tokens):
    operands = list()
    for token in tokens:
        if token.isdigit():
            operands.append(int(token))
        else:
            try:
                operation = OPERATOR2FUNC[token]
            except KeyError:
                raise Exception('unknown operation {0!r}'.format(token))
            try:
                operand_b = operands.pop()
                operand_a = operands.pop()
            except IndexError:
                raise Exception(
                    'not enough operands on stack ({0}) for {1!r}'.format(
                        operands, token
                    )
                )
            operands.append(operation(operand_a, operand_b))

    if len(operands) != 1:
        raise Exception('still excess operands on stack: {0}'.format(operands))

    return operands.pop()