def postfix_eval(input_str):
"""Evaluates a postfix expression"""
"""Input argument: a string containing a postfix expression where tokens
are space separated. Tokens are either operators + - * / ^ or numbers
Returns the result of the expression evaluation.
Raises an PostfixFormatException if the input is not well-formed"""
operators = ["<<", ">>", "**", "*", "/", "+", "-"]
equation = input_str.split()
stack = Stack(len(equation))
for i in range(len(equation)):
if is_num(equation[i]):
stack.push(equation[i])
elif equation[i] in operators:
if stack.size() < 2:
raise PostfixFormatException("Insufficient operands")
first_num = stack.pop()
second_num = stack.pop()
if first_num == "0" and equation[i] == "/":
raise ValueError
try:
total = eval(str(second_num) + str(equation[i]) + str(first_num))
except TypeError:
raise PostfixFormatException("Illegal bit shift operand")
stack.push(str(total))
else:
raise PostfixFormatException("Invalid token")
if stack.size() > 1:
raise PostfixFormatException("Too many operands")
if stack.size() == 0:
return ""
return float((stack.peek()))
def infix_to_postfix(input_str):
'''Converts an infix expression to an equivalent postfix expression
Input argument: a string containing an infix expression where tokens are
space separated. Tokens are either operators + - * / ** >> << parentheses ( ) or numbers
Returns a String containing a postfix expression '''
operators = Stack(30)
input_list = input_str.split(" ")
postfix = ""
for i in range(len(input_list)):
type = type_check(input_list[i])
if type == 5:
operators.push(input_list[i])
elif type == 6:
while not operators.is_empty() and operators.peek() != "(":
postfix += operators.pop() + " "
operators.pop()
elif type == 0:
postfix += input_list[i] + " "
else:
if operators.is_empty():
operators.push(input_list[i])
else:
while not operators.is_empty() and (
type <= type_check(operators.peek()) < 5
and not type == type_check(operators.peek()) == 3):
postfix += operators.pop() + " "
operators.push(input_list[i])
while not operators.is_empty():
postfix += operators.pop() + " "
return postfix[:len(postfix) - 1]
def postfix_eval(input_str):
"""Evaluates a postfix expression"""
"""Input argument: a string containing a postfix expression where tokens
are space separated. Tokens are either operators + - * / ** or numbers
Returns the result of the expression evaluation.
Raises an PostfixFormatException if the input is not well-formed"""
stack = Stack(30)
input = input_str.split()
for item in input:
temp = item.replace('.', '', 1)
temp = temp.replace('-', '', 1)
if item.isalpha():
raise PostfixFormatException("Invalid token")
elif temp.isdigit():
stack.push(item)
else:
if stack.num_items < 2:
raise PostfixFormatException("Insufficient operands")
val1 = stack.pop()
val2 = stack.pop()
if item == '/' and val1 == '0' or val1 == '0.0':
raise ValueError
if (item == '>>' or item == '<<') and (val1.find('.') != -1
or val2.find('.') != -1):
raise PostfixFormatException("Illegal bit shift operand")
stack.push(str(eval(val2 + item + val1)))
res = stack.pop()
if stack.num_items > 0:
raise PostfixFormatException("Too many operands")
if res.find('.') is not -1:
return float(res)
else:
return int(res)
def prefix_to_postfix(input_str):
"""Converts a prefix expression to an equivalent postfix expression"""
input_list=input_str.split()
reverse_list=input_list[::-1]
s=Stack(30)
for item in reverse_list:
if isNumber(item):
s.push(item)
if item == '+' or item == '-' or item == '*' or item == '/' or item == '^':
op1=s.pop()
op2=s.pop()
s.push(op1 + ' ' + op2 + ' ' + item)
return(s.pop())
# """Input argument: a string containing a prefix expression where tokens are
# space separated. Tokens are either operators + - * / ^ parentheses ( ) or numbers
# Returns a String containing a postfix expression(tokens are space separated)"""
#print(infix_to_postfix("2 * 3 * ( 4 + 5 )"))
#print(infix_to_postfix("3 + 4 - 2 + ( 7 ^ 2 )"))
#print(infix_to_postfix("3 + 4 * 2 / ( 1 - 5 ) ^ 2 ^ 3"))
#print(postfix_eval("5 2 4 * + 7 + 2 - 4 6 2 / 2 - * + 4 -"))
#print(postfix_eval("99 38 1.2 * 3.6 2.8 / + 6 - 3.7 2 / 5 / + 3 - 23 + 1.1 / 2.2 + 2.4 5 / - 1 - 1.6 3 / 9 / 2.8 * 3 - 6.2 4 / 12.8 2 * 1.1 / 4.4 3.2 1.1 5.2 / 9.9 * - / - + - +"))
#print(infix_to_postfix("6 + 6 * 6 + 2 + 7 - 5 - ( 1 * 8 * 6 + 4 * 7 ^ 2 / 9 ^ 1 ^ 2 / 3 ) ^ 3 + 4 ( 8 ^ 6 ) * 7 * 2 - 8 ^ 8 ^ 9 - 7 + 6 + 6 ^ 4 ^ 6 - 4 ( 3 + 6 ) + 3 * 5 / 8 - 2 ^ 9 / 4 ^ 2 * ( 4 * 9 + 3 - 3 / 5 ^ 3 - 1 ) + 2 - 4 ^ 9" ))
def prefix_to_postfix(input_str):
"""Converts a prefix expression to an equivalent postfix expression"""
"""Input argument: a string containing a prefix expression where tokens are
space separated. Tokens are either operators + - * / ^ parentheses ( ) or numbers
Returns a String containing a postfix expression(tokens are space separated)"""
s = Stack(30)
tokens = input_str.split()
i = len(tokens) - 1
operators = ['+', '-', '*', '/', '<<', '>>', '**']
if input_str == '':
return ''
while i >= 0:
char = tokens[i]
if char.lstrip('-').replace('.', '', 1).isdigit():
s.push(char)
i -= 1
elif char in operators:
op1 = s.pop()
op2 = s.pop()
inf = op1 + ' ' + op2 + ' ' + char
s.push(inf)
i -= 1
else:
break
return s.pop()
def postfix_eval(input_str):
"""Evaluates a postfix expression"""
"""Input argument: a string containing a postfix expression where tokens
are space separated. Tokens are either operators + - * / ** << >> or numbers (integers or floats)
Returns the result of the expression evaluation.
Raises an PostfixFormatException if the input is not well-formed"""
if input_str is None: raise PostfixFormatException
# create list of operands and operators
term_list = input_str.split()
# initialize stack large enough to contain all operands
operand_stack = Stack(2 * len(term_list) // 3 + 1)
# iterate over term_list
for term in term_list:
# check for operatorm, evaluate operators on A & B if True
if operator_present(term) is True:
if operand_stack.size() < 2:
raise PostfixFormatException("Insufficient operands")
B = operand_stack.pop()
A = operand_stack.pop()
operand_stack.push(calculate(
A, # A
B, # B
term) # operator
)
# check for operand, push to stack if True
elif operand_present(term) is True:
operand_stack.push(term)
else:
raise PostfixFormatException("Invalid token")
if len(term_list) % 3 != 0:
raise PostfixFormatException("Too many operands")
return operand_stack.pop()
def postfix_eval(input_str):
inputList = input_str.split()
postStack = Stack(30)
for character in inputList:
try:
float(character)
except:
if character not in ['<<', '>>', '**', '*', '/', '+', '-']:
raise PostfixFormatException("Invalid token")
else:
pass
for item in inputList:
try:
postStack.push(int(item))
except ValueError:
try:
postStack.push(float(item))
except:
if postStack.size() >= 2:
postStack.push(
doMath(postStack.pop(), postStack.pop(), item))
else:
raise PostfixFormatException('Insufficient operands')
if postStack.size() != 1:
raise PostfixFormatException("Too many operands")
return postStack.pop()
def infix_to_postfix(input_str):
"""Converts an infix expression to an equivalent postfix expression"""
"""Input argument: a string containing an infix expression where tokens are
space separated. Tokens are either operators + - * / ** parentheses ( ) or numbers
Returns a String containing a postfix expression """
output = []
stack = Stack(30)
input = input_str.split()
for item in input:
if item.isnumeric():
output.append(item)
elif item == '(':
stack.push(item)
elif item == ')':
while ((not stack.is_empty()) and (stack.peek() != '(')):
val1 = stack.pop()
output.append(val1)
try:
stack.pop()
except:
raise PostfixFormatException("Insufficient operands")
# an operator is encountered
else:
while ((not stack.is_empty()) and orderOfOperations(stack, item)):
output.append(stack.pop())
stack.push(item)
# pop all the operator from the stack
while not stack.is_empty():
output.append(stack.pop())
return " ".join(output)
def infix_to_postfix(input_str):
"""Converts an infix expression to an equivalent postfix expression"""
"""Input argument: a string containing an infix expression where tokens are
space separated. Tokens are either operators + - * / ^ parentheses ( ) or numbers
Returns a String containing a postfix expression """
stack = Stack(30) # Stack of size 30
operators = ["(", ")", ">>", "<<", "**", "*", "/", "+",
"-"] # Allowed operands
final_list = ""
first_run = True
split_string = input_str.split(
) # Split input string into usable chunks in a list
for val in split_string: # Run through every value in list in order
if val == "(":
stack.push("(")
elif val == ")":
popping = True
while popping:
popped_value = stack.pop()
if popped_value == "(":
popping = False
else:
final_list += " " + popped_value
elif val in operators:
popping = True
while popping:
if stack.is_empty():
popping = False
elif stack.peek() == "(":
popping = False
elif (val == ">>"
or val == "<<") and operators.index(stack.peek()) > 3:
popping = False
elif val == "**" and operators.index(stack.peek()) > 3:
popping = False
elif (val == "*"
or val == "/") and operators.index(stack.peek()) > 6:
popping = False
else:
final_list += " " + stack.pop()
stack.push(val)
else:
if first_run:
final_list += str(val)
first_run = False
else:
final_list += " " + str(val)
popping = True
while popping:
if stack.is_empty():
popping = False
else:
final_list += " " + stack.pop()
return final_list
def testInfix(inputString):
inputList = inputString.split()
rpnString = ''
infixStack = Stack(30)
for item in inputList:
if item.isdigit():
rpnString += item
else:
try:
rpnString += str(float(item))
except:
pass
if infixStack.size() > 0:
o1 = item
o2 = infixStack.peek()
if o1 != '**':
if getPrecVal(o1) <= getPrecVal(o2) and infixStack.size() > 0:
rpnString += infixStack.pop()
elif o1 == '**':
if getPrecVal(o1) < getPrecVal(o2) and infixStack.size() > 0:
rpnString += infixStack.pop()
infixStack.push(item)
for i in range(infixStack.size()):
rpnString += infixStack.pop()
return rpnString
def infix_to_postfix(input_str):
"""Converts an infix expression to an equivalent postfix expression"""
"""Input argument: a string containing an infix expression where tokens are
space separated. Tokens are either operators + - * / ^ parentheses ( ) or numbers
Returns a String containing a postfix expression """
stack = Stack(30)
tokens = input_str.split(" ")
RPN = ""
for token in tokens:
if is_int(token) or is_float(token):
if RPN == "":
RPN = token
else:
RPN = RPN + " " + token
elif token == "(":
stack.push(token)
elif token == ")":
while stack.peek() != "(":
RPN = RPN + " " + stack.pop()
stack.pop()
elif is_operator(token):
while (stack.is_empty() == False) and is_operator(
stack.peek()) and has_precedence(token, stack.peek()):
RPN = RPN + " " + stack.pop()
stack.push(token)
while stack.size() > 0:
RPN = RPN + " " + str(stack.pop())
return RPN
def prefix_to_postfix(input_str):
# creates a stack to store operators, operands, and joined expressions
stack = Stack(30)
# change the input string to a list of input operands and operators
input_list = input_str.split()
# creates a list to store the postfix expression
output_list = []
# steps through the input list in reverse
for i in input_list[::-1]:
# adds operands to the stack
try:
float(i)
stack.push(i)
except ValueError:
# checks if i is an operator
if i in ["+", "-", "*", "/", "**", "(", "<<", ">>"]:
# removes the top two values of the stack and adds the operator i to the end
val1 = stack.pop()
val2 = stack.pop()
add = val1 + " " + val2 + " " + i
# adds the new expression to the stack
stack.push(add)
# after the loop goes through the entire input string,
# all items in the stack are popped and added to the output postfix expression
while stack.size() != 0:
output_list.append(stack.pop())
# joins the list of output characters into a string
output = ' '.join(output_list)
# returns the postfix expression
return output
def prefix_to_postfix(input_str):
"""Converts a prefix expression to an equivalent postfix expression"""
"""Input argument: a string containing a prefix expression where tokens are
space separated. Tokens are either operators + - * / ** parentheses ( ) or numbers
Returns a String containing a postfix expression(tokens are space separated)"""
stack = Stack(30)
operators = ['+', '-', '*', '/', '**']
input = input_str.split()
result = ""
# Reversing the order
input_reverse = input[::-1]
# iterating through individual tokens
for item in input_reverse:
# if token is operator
if item in operators:
a = stack.pop()
b = stack.pop()
temp = a + b + item
stack.push(temp)
else:
stack.push(item)
# printing final output
while not stack.is_empty():
result = result + stack.pop()
return " ".join(result)
def prefix_to_postfix(input_str):
'''Converts a prefix expression to an equivalent postfix expression
Input argument: a string containing a prefix expression where tokens are
space separated. Tokens are either operators + - * / ** >> << parentheses ( ) or numbers
Returns a String containing a postfix expression(tokens are space separated)'''
op_lst = ["+", "-", "*", "/", "**"] #list of operators
val_lst = input_str.split(" ") #list of individual tokens
val_lst.reverse()
stack = Stack(len(input_str)) #stack to push and pop our values
if input_str == '':
return ''
for i in val_lst:
if i not in op_lst:
try: #checks validity of tokens
a = float(i)
if str(abs(int(a))).isdigit(
): #if i is a number i is pushed on to stack
stack.push(i)
except ValueError: #if cant't be casted as a float then its invalid
raise PostfixFormatException("Invalid token")
elif i in op_lst:
try: #checks to see if theres enough items to concatenate
val1 = stack.pop()
val2 = stack.pop()
except IndexError: #if an index error is raised from the stack then theres not enough items
raise PostfixFormatException("Invalid Prefix Expression")
result = str(val1) + " " + str(val2) + " " + i
stack.push(result)
if stack.size() == 1:
return str(stack.pop())
else: #not enough operators
raise PostfixFormatException("Invalid Prefix Expression")
def test_empty_stack(self):
stack = Stack(0)
with self.assertRaises(IndexError):
stack.pop()
with self.assertRaises(IndexError):
stack.peek()
with self.assertRaises(IndexError):
stack.push(1)
def test2(self):
stack2 = Stack(5)
stack2.push(3)
stacktest = Stack(0)
self.assertEqual(stack2.pop(), 3)
with self.assertRaises(IndexError): #checks for exception
stacktest.pop()
with self.assertRaises(IndexError): #checks for exception
stacktest.peek()
def test_pop(self):
stack = Stack(3, [8, 12, 52])
self.assertEqual(stack.pop(), 52)
self.assertEqual(stack.pop(), 12)
self.assertEqual(stack.num_items, 1)
self.assertEqual(stack.pop(), 8)
self.assertTrue(stack.is_empty())
with self.assertRaises(IndexError): # used to check for exception
stack.pop()
def test_size(self):
stack1 = Stack(5)
stack2 = Stack(3, [8, 12, 52])
self.assertEqual(stack1.size(), 0)
self.assertEqual(stack2.size(), 3)
stack1.push(5)
self.assertEqual(stack1.size(), 1)
stack2.pop()
self.assertEqual(stack2.size(), 2)
def postfix_eval(input_str):
"""Evaluates a postfix expression"""
"""Input argument: a string containing a postfix expression where tokens
are space separated. Tokens are either operators + - * / ^ or numbers
Returns the result of the expression evaluation.
Raises an PostfixFormatException if the input is not well-formed"""
s = Stack(30)
tokens = input_str.split()
operators = ['+', '-', '*', '/', '**', '<<', '>>']
if input_str == '':
return ''
for char in tokens:
if char in operators:
try:
n2 = s.pop()
n1 = s.pop()
except IndexError:
raise PostfixFormatException('Insufficient operands')
if char == '+':
result = n1 + n2
s.push(result)
if char == '-':
result = n1 - n2
s.push(result)
if char == '*':
result = n1 * n2
s.push(result)
if char == '/':
if n2 == 0:
raise ValueError('Cannot divide by 0!')
result = n1 / n2
s.push(result)
if char == '**':
result = n1**n2
s.push(result)
if char == '<<':
if type(n1) == float or type(n2) == float:
raise PostfixFormatException('Illegal bit shift operand')
result = n1 << n2
s.push(result)
if char == '>>':
if type(n1) == float or type(n2) == float:
raise PostfixFormatException('Illegal bit shift operand')
result = n1 >> n2
s.push(result)
elif char.lstrip('-').replace('.', '', 1).isdigit():
if '.' not in char:
s.push(int(char))
else:
s.push(float(char))
else:
raise PostfixFormatException('Invalid token')
final = s.pop()
if not s.is_empty():
raise PostfixFormatException('Too many operands')
return final
def test4(self):
stack = Stack(3)
stack.push(None)
self.assertEqual(stack.peek(), None)
stack.push(3)
stack.push(-2)
stack.pop()
stack.pop()
stack.pop()
self.assertEqual(stack.size(), 0)
def test_simple(self):
stack = Stack(5)
stack.push(0)
self.assertFalse(stack.is_empty())
self.assertFalse(stack.is_full())
self.assertEqual(stack.size(), 1)
stack.push(4)
stack.push(9)
self.assertEqual(stack.size(), 3)
stack.push(8)
stack.push(7)
with self.assertRaises(IndexError):
stack.push(6)
stack.pop()
self.assertEqual(stack.size(), 4)
self.assertEqual(stack.peek(), 8)
stack.pop()
stack.pop()
stack.pop()
self.assertEqual(stack.pop(), 0)
self.assertEqual(stack.size(), 0)
with self.assertRaises(IndexError):
stack.pop()
with self.assertRaises(IndexError):
stack.peek()
def postfix_eval(input_str):
# Evaluates a postfix expression
# Input argument: a string containing a postfix expression where tokens
# are space separated. Tokens are either operators + - * / ^ or numbers
# Returns the result of the expression evaluation.
# Raises an PostfixFormatException if the input is not well-formed
#Delimiter
postfixList = input_str.split(" ")
#Creates Stack with capacity of the lenght of the delimited list
postfixStack = Stack(len(postfixList))
#For each element in the pfList
for token in postfixList:
try:
#Try to push to stack if it is a number
postfixStack.push(ast.literal_eval(token))
except:
#If a 'normal' operator is encountered
if token in "*/+-^**":
try:
#Pops the top two numbers on the stack then applies the
#token operator with pfMath()
numberTwo = postfixStack.pop()
numberOne = postfixStack.pop()
postfixStack.push(pfMath(token, numberOne, numberTwo))
except:
#Checks for div 0 otherwise raises Insufficient operands
if numberTwo == 0:
raise ValueError("Undefined: Can't Divide By 0")
else:
raise PostfixFormatException("Insufficient operands")
#For bit shift
elif token in "<<>>":
try:
#Attemps to pop top two on the stack
numberShifter = postfixStack.pop()
numberBase = postfixStack.pop()
#Left bit Shift
if token == "<<":
postfixStack.push(numberBase << numberShifter)
#Right bit Shift
else:
postfixStack.push(numberBase >> numberShifter)
#Can't bit shift raise error
except:
raise PostfixFormatException("Illegal bit shift operand")
#Not a token or number
else:
raise PostfixFormatException("Invalid token")
#End of postfixList checks what is on the stack
if postfixStack.size() != 1:
raise PostfixFormatException("Too many operands")
#Returns the evaluated postfix
return postfixStack.pop()
def stack_test(a):
"""
-------------------------------------------------------
Tests
Use: stack_test(a)
-------------------------------------------------------
Preconditions:
a - list of data (list of ?)
Postconditions:
the methods of Stack are tested for both empty and
non-empty stacks using the data in a:
is_empty, push, pop, peek
-------------------------------------------------------
"""
s = Stack()
# tests for the stack methods go here
# print the results of the method calls and verify by hand
print("is_empty for an empty stack:")
is_empty = s.is_empty()
print("{}".format(is_empty))
try:
print("pop empty:")
pop = s.pop()
print("{}".format(pop))
except:
print("pop empty failed")
try:
print("peek empty:")
peek = s.peek()
print("{}".format(peek))
except:
print("peek empty failed")
try:
print("push:")
for j in a:
s.push(j)
for i in s:
print("{}".format(i))
except:
print("push failed")
try:
print("pop:")
pop = s.pop()
print("{}".format(pop))
except:
print("pop failed")
try:
print("peek:")
peek = s.peek()
print("{}".format(peek))
except:
print("peek failed")
return
def postfix_eval(input_str):
'''Evaluates a postfix expression
Input argument: a string containing a postfix expression where tokens
are space separated. Tokens are either operators + - * / ** >> << or numbers.
Returns the result of the expression evaluation.
Raises an PostfixFormatException if the input is not well-formed
DO NOT USE PYTHON'S EVAL FUNCTION!!!'''
if postfix_valid(input_str):
numbers = Stack(30)
input_list = input_str.split(" ")
i = 0
while i < len(input_list):
type = type_check(input_list[i])
if type == 0:
numbers.push(input_list[i])
else:
if input_list[i] == "+":
a = float(numbers.pop())
b = float(numbers.pop())
numbers.push(a + b)
elif input_list[i] == "-":
a = float(numbers.pop())
b = float(numbers.pop())
numbers.push(b - a)
elif input_list[i] == "*":
a = float(numbers.pop())
b = float(numbers.pop())
numbers.push(a * b)
elif input_list[i] == "/":
a = float(numbers.pop())
b = float(numbers.pop())
if a == 0:
raise ValueError
numbers.push(b / a)
elif input_list[i] == "**":
a = float(numbers.pop())
b = float(numbers.pop())
numbers.push(b**a)
elif input_list[i] == "<<":
a = float(numbers.pop())
b = float(numbers.pop())
if a == int(a) and b == int(b):
numbers.push(int(b) << int(a))
else:
raise PostfixFormatException(
"Illegal bit shift operand")
elif input_list[i] == ">>":
a = float(numbers.pop())
b = float(numbers.pop())
if a == int(a) and b == int(b):
numbers.push(int(b) >> int(a))
else:
raise PostfixFormatException(
"Illegal bit shift operand")
i += 1
if int(numbers.peek()) == float(numbers.peek()):
return int(numbers.pop())
return numbers.pop()
def infix_to_postfix(input_str):
# Converts an infix expression to an equivalent postfix expression
# Input argument: a string containing an infix expression where tokens are
# space separated. Tokens are either operators + - * / ^ parentheses ( ) or numbers
# Returns a String containing a postfix expression
#Precedent
orderOfOperations = {
'<<': 5,
'>>': 5,
'^': 4,
'**': 4,
'*': 2,
'/': 2,
'+': 1,
'-': 1,
'(': 0
}
#Delimiter
infixList = input_str.split(" ")
#Sets up stack with capacity of the len of the delimited string
opStack = Stack(len(infixList))
#Output holder
postfixOutput = []
#For each element in the list of infix
for token in infixList:
try:
#Using ast.literal_eval
postfixOutput.append(ast.literal_eval(token))
except:
#Open ( push
if token == "(":
opStack.push(token)
#Close ) stack pop
elif token == ")":
head = opStack.pop()
while head != "(":
postfixOutput.append(head)
head = opStack.pop()
elif orderOfOperations[token] == 4:
opStack.push(token)
else:
#When the stack isn't empty and the ooO on the stack is greater then the current ooO
while not (opStack.is_empty()) and (
orderOfOperations[opStack.peek()] >=
orderOfOperations[token]):
postfixOutput.append(opStack.pop())
opStack.push(token)
while not (opStack.is_empty()):
postfixOutput.append(opStack.pop())
#Recreate the string join together
return " ".join(str(pfUnit) for pfUnit in postfixOutput)
def test_simple_1(self):
stack = Stack(3)
self.assertRaises(IndexError, stack.peek)
stack.push(0)
stack.push(1)
stack.push(2)
self.assertRaises(IndexError, stack.push, 3)
self.assertTrue(stack.is_full())
self.assertEqual(stack.size(),3)
stack.pop()
stack.pop()
self.assertEqual(stack.pop(), 0)
def postfix_eval(input_str):
'''Evaluates a postfix expression
Input argument: a string containing a postfix expression where tokens
are space separated. Tokens are either operators + - * / ** >> << or numbers.
Returns the result of the expression evaluation.
Raises an PostfixFormatException if the input is not well-formed
DO NOT USE PYTHON'S EVAL FUNCTION!!!'''
op_lst = ["+", "-", "*", "/", "**"] #list of operators
val_lst = input_str.split(" ") #list of individual tokens
stack = Stack(len(input_str)) #stack to push and pop our values
if input_str == "":
return "" #basecase
for i in val_lst: #loops throught the input string
if i not in op_lst:
try: #checks validity of tokens
if i.isdigit(): #if i is a digit i is pushed on to stack
stack.push(int(i))
else: #pushes it as float
stack.push(float(i))
except ValueError: #if cant't be casted as a float then its invalid
raise PostfixFormatException("Invalid token")
elif i in op_lst:
try: #checks to see if theres enough values to do operation
val2 = stack.pop()
val1 = stack.pop()
except IndexError: #if an index error is raised from the stack then theres not enough values
raise PostfixFormatException("Insufficient operands")
if i == "+":
result = val1 + val2
stack.push(result)
if i == "-":
result = val1 - val2
stack.push(result)
if i == "/":
if val2 == 0:
raise ValueError("float division by 0")
else:
result = val1 / val2
stack.push(result)
if i == "*":
result = val1 * val2
stack.push(result)
if i == "**":
result = val1**val2
stack.push(result)
if stack.size() == 1:
return stack.pop()
else: #if stack has more than one item left after iteration of val_Lst then too many operands
raise PostfixFormatException("Too many operands")
def prefix_to_postfix(input_str):
'''Converts a prefix expression to an equivalent postfix expression
Input argument: a string containing a prefix expression where tokens are
space separated. Tokens are either operators + - * / ** >> << or numbers
Returns a String containing a postfix expression (tokens are space separated)'''
input_list = input_str.split(" ")
nums = Stack(30)
for i in range(1, len(input_list) + 1):
type = type_check(input_list[len(input_list) - i])
if type == 0:
nums.push(input_list[len(input_list) - i])
else:
nums.push(nums.pop() + " " + nums.pop() + " " +
input_list[len(input_list) - i])
return nums.pop()
def test3(self):
stack = Stack(2)
with self.assertRaises(
IndexError): # uses context manager to check exception
stack.pop()
with self.assertRaises(
IndexError): # uses context manager to check exception
stack.peek()
stack.push(3)
self.assertNotEqual(stack.peek(), 2)
stack.push(2)
self.assertEqual(stack.peek(), 2)
with self.assertRaises(
IndexError): # uses context manager to check exception
stack.push(7)
def test_pop(self):
"""Empty stack will return indexError when popping"""
stack = Stack(5, [])
with self.assertRaises(IndexError):
stack.pop()
"""Testing non-empty stacks, item is removed from the stack"""
stack.push(-1000)
self.assertEqual(stack.__repr__(), "Stack(5, [-1000])")
self.assertEqual(stack.pop(), -1000)
self.assertEqual(stack.__repr__(), "Stack(5, [])")
stack2 = Stack(5, [1, 2, 3, 4, 5])
self.assertEqual(stack2.__repr__(), "Stack(5, [1, 2, 3, 4, 5])")
self.assertEqual(stack2.pop(), 5)
self.assertEqual(stack2.__repr__(), "Stack(5, [1, 2, 3, 4])")
def parse_arithmetic(expression):
operations = Stack()
numbers = Stack()
for c in expression:
if c == '(': pass
elif c == '+' or c == '*':
operations.push(c)
elif c == ')':
operator = operations.pop()
value2 = numbers.pop()
value1 = numbers.pop()
if operator == '+':
numbers.push(value1 + value2)
elif operator == '*':
numbers.push(value1 * value2)
else:
numbers.push(int(c))
return numbers.pop()
class TestStack(unittest.TestCase):
def setUp(self):
self.stack = Stack()
def test_init(self):
self.assertEqual(self.stack.get_size(), 0)
new_stack = Stack("Bob")
self.assertEqual(new_stack.get_size(), 1)
def test_push(self):
initial_size = self.stack.get_size()
self.stack.push("Bob")
self.assertEqual(self.stack.get_size(), initial_size + 1)
def test_peek(self):
self.stack.push("Adrian")
self.stack.push("Bob")
self.stack.push("Claire")
self.assertEqual(self.stack.peek(), "Claire")
def test_pop(self):
self.stack.push("Adrian")
self.stack.push("Bob")
self.stack.push("Claire")
initial_size = self.stack.get_size()
popped_item = self.stack.pop()
self.assertEqual(popped_item, "Claire")
self.assertEqual(self.stack.get_size(), initial_size - 1)
def test_clear(self):
self.stack.push("Adrian")
self.stack.push("Bob")
self.stack.push("Claire")
self.assertEqual(self.stack.get_size(), 3)
self.stack.clear()
self.assertEqual(self.stack.get_size(), 0)
def test_get_size(self):
self.stack.push("Bob")
self.assertEqual(self.stack.get_size(), 1)
from stack_array import Stack
s = Stack()
print s.pop() # None
s.push('to')
s.push('be')
s.push('or')
s.push('not')
s.push('to')
print s.pop() # to
s.push('be')
print s.pop() # be
print s.pop() # not
s.push('that')
print s.pop() # that
print s.pop() # or
print s.pop() # be
s.push('is')
