Обратный польский калькулятор Обработка исключений в Python

Question

Итак, я почти закончил эту программу, но не могу понять, как правильно обрабатывать исключения на основе этих правил:

Вы должны обработать следующие ситуации (ошибки):

Слишком много операторов (+ - / *)

Слишком много операндов (двойников)

Деление на ноль

Незамедлительный

Для этого задания вы должны написать программу, которая будет рассчитывать результаты выражений обратного польского, предоставленных пользователем.

Вы должны использовать связанный список для поддержки стека для этой программы (реализации массива стека не получат полный кредит).

Вы должны обрабатывать следующие ситуации (ошибки): Слишком много операторов (+ - / *) Слишком много операндов (удваивается) Деление на ноль

Программа примет польское выражение, которое разделяет операторы и операнды одним пробелом, и завершает выражение новой строкой.

Программа будет продолжать принимать и оценивать выражения до тех пор, пока пользователь сам не введет ноль (0) в строку, за которой следует новая строка.

Ваш пример выходных данных должен показать обработку всех состояний ошибки, а также использовать все операторы.

Пример ввода-вывода: (примечание: форматирование вывода не является критической проблемой)

Input    Output
10 15 +  25
10 15 -  -5
2.5 3.5 +    6 (or 6.0)
10 0 /   Error: Division by zero
10 20 * /    Error: Too many operators
12 20 30 /   Error: Too many operands
-10 -30 -    20
100 10 50 25 / * - -2 /  -40

программа

Вот что я получил так далеко:

# !/usr/bin/env python

import sys
import re

class LinkedStack:
  #LIFO Stack implementation using a singly linked list for storage.

  #-------------------------- nested _Node class --------------------------
  class _Node:
    #Lightweight, nonpublic class for storing a singly linked node.
    __slots__ = '_element', '_next' # streamline memory usage

    def __init__(self, element, next): # initialize node’s fields
        self._element = element # reference to user’s element
        self._next = next # reference to next node

  def __init__(self):
    #Create an empty stack.
    self._head = None # reference to the head node
    self._size = 0 # number of stack elements

  @property
  def __len__(self):
    #Return the number of elements in the stack.
    return self._size

  def is_empty(self):
    #Return True if the stack is empty.
    return self._size == 0

  def push(self, e):
    #Add element e to the top of the stack.
    self._head = self._Node(e, self._head) # create and link a new node
    self._size += 1

  def pop(self):
    i = self._head._element
    self._head = self._head._next
    self._size -= 1
    return i

ls = LinkedStack()

# Changing the operators to behave like functions via lambda
# Needed for stack push and pop rules down below
# '+' : (lambda x, y: x + y) is same as def '+' (x,y): return x + y  
operators = {
  '+' : (lambda x, y: x + y),
  '-' : (lambda x, y: y - x),
  '*' : (lambda x, y: x * y),
  '/' : (lambda x, y: y / x)
}


def evaluate(tokens):
  # Evaluate RPN expression (given as string of tokens)
  for i in tokens:
    if i in operators:
        ls.push(operators[i](ls.pop(), ls.pop()))
    else:
      ls.push(float(i))
  return ls.pop()


def main():
  while True:
    print("Input the expression: ", end='')

    # Read line by line from stdin + tokenize line + evaluates line
    tokens = re.split(" *", sys.stdin.readline().strip())

    # Output the stack
    print("Stack: ",tokens)

    # Output result
    if not tokens:
      break
    print("Result: ",evaluate(tokens),'\n')

# Call main
if __name__=="__main__":
  main()

Спасибо за вашу помощь, ребята!

Answer 1

Предположим, что некоторые входные n числа и o операторы. Похоже, что o == n-1 для правильного ввода. Так что, возможно, вы можете утверждать, что o == n-1, Если операторов слишком много, то возможно o > n-1 или слишком мало, o < n-1, Чтобы обнаружить деление на ноль, вы можете проверить "правый операнд", заданный запросом на деление, и утверждать, что оно не равно нулю.