Updated postfix_evaluation.py to support Unary operators

data_structures/stacks/postfix_evaluation.py

@@ -1,4 +1,11 @@
 """
+The Reverse Polish Nation also known as Polish postfix notation
+or simply postfix notation.
+https://en.wikipedia.org/wiki/Reverse_Polish_notation
+Classic examples of simple stack implementations
+Valid operators are +, -, *, /.
+Each operand may be an integer or another expression.
+
 Output:
 
 Enter a Postfix Equation (space separated) = 5 6 9 * +
@@ -17,52 +24,197 @@
         Result =  59
 """
 
-import operator as op
+
+def get_number(data: str) -> tuple[bool, int] | tuple[bool, float] | tuple[bool, str]:
+    """
+    Converts the given data to appropriate number if it is indeed a number, else returns
+    the data as it is with a False flag. This function also serves as a check of whether
+    the input is a number or not.
+
+    Parameters
+    ----------
+    data : str
+        The data which needs to be converted to the appropriate number
+
+    Returns
+    -------
+    bool,  int or float
+        Returns a tuple of (a, b) where 'a' is True if data is indeed a number (integer
+        or numeric) and 'b' is either an integer of a floating point number.
+        If 'a' is False, then b is 'data'
+    """
+    int_val = 0
+    float_val = 0.0
+    try:
+        int_val = int(data)
+        return True, int_val
+    except ValueError:
+        try:
+            float_val = float(data)
+            return True, float_val
+        except ValueError:
+            return False, data
+
+
+def is_operator(data: str) -> bool:
+    """
+    Checks whether a given input is one of the valid operators or not.
+    Valid operators being '-', '+', '*', '^' and '/'.
+
+    Parameters
+    ----------
+    data : str
+        The value that needs to be checked for operator
+
+    Returns
+    -------
+    bool
+        True if data is an operator else False.
+    """
+    return data in ["-", "+", "*", "^", "/"]
 
 
-def solve(post_fix):
+def evaluate(post_fix: list, verbose: bool = False) -> int | float | str | None:
+    """
+    Function that evaluates postfix expression using a stack.
+    >>> evaluate(["2", "1", "+", "3", "*"])
+    9
+    >>> evaluate(["4", "13", "5", "/", "+"])
+    6.6
+    >>> evaluate(["2", "-", "3", "+"])
+    1
+    >>> evaluate([])
+    0
+
+    Parameters
+    ----------
+    post_fix : list
+        The postfix expression tokenized into operators and operands and stored as a
+        python list
+
+    verbose : bool
+        Display stack contents while evaluating the expression if verbose is True
+
+    Returns
+    -------
+    int
+        The evaluated value
+    """
     stack = []
-    div = lambda x, y: int(x / y)  # noqa: E731 integer division operation
     opr = {
-        "^": op.pow,
-        "*": op.mul,
-        "/": div,
-        "+": op.add,
-        "-": op.sub,
+        "^": lambda p, q: p**q,
+        "*": lambda p, q: p * q,
+        "/": lambda p, q: p / q,
+        "+": lambda p, q: p + q,
+        "-": lambda p, q: p - q,
     }  # operators & their respective operation
+    if len(post_fix) > 0:
+        if verbose:
+            # print table header
+            print("Symbol".center(8), "Action".center(12), "Stack", sep=" | ")
+            print("-" * (30 + len(post_fix)))
+        for x in post_fix:
+            is_number, x = get_number(x)
+            if is_number:  # if x is a number (integer, float)
+                stack.append(x)  # append x to stack
+                if verbose:
+                    # output in tabular format
+                    print(
+                        str(x).rjust(8),
+                        ("push(" + str(x) + ")").ljust(12),
+                        stack,
+                        sep=" | ",
+                    )
+            elif is_operator(x):
+                # If only 1 value is inside stack and + or - is encountered
+                # then this is unary + or - case
+                if x in ["-", "+"] and len(stack) < 2:
+                    b = stack.pop()  # pop stack
+                    if x == "-":
+                        stack.append(-b)  # negate b and push again into stack
+                    else:  # when x is unary +
+                        stack.append(b)
+                    if verbose:
+                        # output in tabular format
+                        print(
+                            "".rjust(8),
+                            ("pop(" + str(b) + ")").ljust(12),
+                            stack,
+                            sep=" | ",
+                        )
+                        print(
+                            str(x).rjust(8),
+                            ("push(" + str(x) + str(b) + ")").ljust(12),
+                            stack,
+                            sep=" | ",
+                        )
+                else:
+                    b = stack.pop()  # pop stack
+                    if verbose:
+                        # output in tabular format
+                        print(
+                            "".rjust(8),
+                            ("pop(" + str(b) + ")").ljust(12),
+                            stack,
+                            sep=" | ",
+                        )
+
+                    a = stack.pop()  # pop stack
+                    if verbose:
+                        # output in tabular format
+                        print(
+                            "".rjust(8),
+                            ("pop(" + str(a) + ")").ljust(12),
+                            stack,
+                            sep=" | ",
+                        )
+                    # evaluate the 2 values popped from stack & push result to stack
+                    stack.append(opr[x](a, b))
+                    if verbose:
+                        # output in tabular format
+                        print(
+                            str(x).rjust(8),
+                            ("push(" + str(a) + str(x) + str(b) + ")").ljust(12),
+                            stack,
+                            sep=" | ",
+                        )
+            else:
+                print(f"{x} is neither a number, nor a valid operator")
+                break
+        # If everything executed correctly,the stack will contain
+        # only one element which is the result
+        result = stack[0] if len(stack) == 1 else None
+        return result
+    return 0
+
+
+def is_yes(val: str) -> bool:
+    """
+    Function that checks whether a user has entered any representation of a Yes (y, Y).
+    Any other input is considered as a No.
+
+    Parameters
+    -----------
+    val : str
+        The value entered by user
 
-    # print table header
-    print("Symbol".center(8), "Action".center(12), "Stack", sep=" | ")
-    print("-" * (30 + len(post_fix)))
-
-    for x in post_fix:
-        if x.isdigit():  # if x in digit
-            stack.append(x)  # append x to stack
-            # output in tabular format
-            print(x.rjust(8), ("push(" + x + ")").ljust(12), ",".join(stack), sep=" | ")
-        else:
-            b = stack.pop()  # pop stack
-            # output in tabular format
-            print("".rjust(8), ("pop(" + b + ")").ljust(12), ",".join(stack), sep=" | ")
-
-            a = stack.pop()  # pop stack
-            # output in tabular format
-            print("".rjust(8), ("pop(" + a + ")").ljust(12), ",".join(stack), sep=" | ")
-
-            stack.append(
-                str(opr[x](int(a), int(b)))
-            )  # evaluate the 2 values popped from stack & push result to stack
-            # output in tabular format
-            print(
-                x.rjust(8),
-                ("push(" + a + x + b + ")").ljust(12),
-                ",".join(stack),
-                sep=" | ",
-            )
-
-    return int(stack[0])
+    Returns
+    -------
+    bool
+        True if Yes, otherwise False
+    """
+    return val in ["Y", "y"]
 
 
 if __name__ == "__main__":
-    Postfix = input("\n\nEnter a Postfix Equation (space separated) = ").split(" ")
-    print("\n\tResult = ", solve(Postfix))
+    loop = True
+    # Creating a loop so that user can evaluate postfix expression multiple times
+    while loop:
+        expression = input("Enter a Postfix Expression (space separated): ").split(" ")
+        choice = input("Do you want to see stack contents while evaluating? [y/N]: ")
+        display = is_yes(choice)
+        output = evaluate(expression, display)
+        if output is not None:
+            print("Result = ", output)
+        choice = input("Do you want to enter another expression? [y/N]: ")
+        loop = is_yes(choice)