def main():
parser = argparse.ArgumentParser(description='Process operator and arguments')
parser.add_argument('operator')
parser.add_argument('arguments', type=float, nargs='+')
args = parser.parse_args()
try:
print evaluate(args.operator, *args.arguments)
except Exception as e:
print "Error: " + e.message
def check_answer(x, y, op, result, user_choice):
if (evaluate(x, y, op) == result) and (user_choice == True ):
return True
elif (evaluate(x, y, op) == result) and (user_choice == False):
return False
elif (evaluate(x, y, op) != result) and (user_choice == False):
return True
elif (evaluate(x, y, op) != result) and (user_choice == True):
return False
def test_invalid_expression(self):
"""
Make sure code will behave correctly for invalid input
"""
data = [
"1/0",
"import os",
]
for expression in data:
with self.assertRaises(StandardError):
evaluate(expression)
def test_invalid_expression(self):
"""
Make sure code will behave correctly for invalid input
"""
data = [
"1/0",
"import os",
]
for expression in data:
with self.assertRaises(StandardError):
evaluate(expression)
def test_multiple_hex_to_decimal(self):
self.assertEqual(calc.evaluate("0x00"), 0)
self.assertEqual(calc.evaluate("0xFF"), 255)
self.assertEqual(calc.evaluate("0x0000000000000000000000000000000000000"), 0)
self.assertEqual(
calc.evaluate("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"), 356811923176489970264571492362373784095686655
)
self.assertEqual(calc.evaluate("0x1234567890"), 78187493520)
self.assertEqual(calc.evaluate("0xABCDEF"), 11259375)
self.assertEqual(calc.evaluate("0xA83F"), 43071)
self.assertEqual(calc.evaluate("0x1AB5"), 6837)
self.assertEqual(calc.evaluate("0x9D2C"), 40236)
self.assertEqual(calc.evaluate("0xD6B4"), 54964)
def generate_quiz():
x = randint(0,10)
y = randint(1,10)
op = choice(['+', '-', '*', '/'])
result = evaluate(x, y, op)+randint(-2,2)
# Hint: Return [x, y, op, result]
return [x, y, op, result]
def generate_quiz():
# Hint: Return [x, y, op, result]
x = randint(0, 20)
y = randint(0, 20)
op = choice(["+", "-", "*", "/"])
error = randint(-1, 1)
result = evaluate(x, y, op) + error
return x, y, op, result
def check_answer(x, y, op, result, user_choice):
if evaluate(x, y, op) == result:
if user_choice == True:
return True
else:
return False
else:
if user_choice == False:
return True
else:
return False
pass
def test_simple_expression(self):
"""
Test expression without functions or constants
"""
data = [
("84-9*3", 57),
("8**4", 4096),
("3*(2*5)**3/(123-32+9)", 30),
]
for expression, expected in data:
result = evaluate(expression)
msg = "{} evaluated to: {}. Expected {}".format(
expression, result, expected)
self.assertEquals(result, expected, msg)
def test_simple_expression(self):
"""
Test expression without functions or constants
"""
data = [
("84-9*3", 57),
("8**4", 4096),
("3*(2*5)**3/(123-32+9)", 30),
]
for expression, expected in data:
result = evaluate(expression)
msg = "{} evaluated to: {}. Expected {}".format(
expression, result, expected)
self.assertEquals(result, expected, msg)
def test_complex_expression(self):
"""
Test expression with functions or constants
"""
data = [
("2*log(exp(2))", 4),
("cos(2*pi)", 1),
("log(8,2)", 3),
]
for expression, expected in data:
result = evaluate(expression)
msg = "{} evaluated to: {}. Expected {}".format(
expression, result, expected)
self.assertEquals(result, expected, msg)
def test_complex_expression(self):
"""
Test expression with functions or constants
"""
data = [
("2*log(exp(2))", 4),
("cos(2*pi)", 1),
("log(8,2)", 3),
]
for expression, expected in data:
result = evaluate(expression)
msg = "{} evaluated to: {}. Expected {}".format(
expression, result, expected)
self.assertEquals(result, expected, msg)
def test_multiple_digits(self):
self.assertEqual(calc.evaluate('99999'), 99999)
self.assertEqual(calc.evaluate('12345'), 12345)
self.assertEqual(calc.evaluate('99999'), 99999)
self.assertEqual(calc.evaluate('99'), 99)
self.assertEqual(calc.evaluate('00'), 00)
def test_single_digit(self):
i = 0
for c in '0123456789':
self.assertEqual(calc.evaluate(c),i)
i = i + 1
def test_floating_numbers(self):
self.assertEqual(calc.evaluate('123.456'),123.456)
self.assertEqual(calc.evaluate('-123.456'),-123.456)
def test_multiple_digits(self):
self.assertEqual(calc.evaluate('99999'),99999)
self.assertEqual(calc.evaluate('12345'),12345)
self.assertEqual(calc.evaluate('99999'),99999)
self.assertEqual(calc.evaluate('99'),99)
self.assertEqual(calc.evaluate('00'),00)
def test_multiple_digits(self):
self.assertEqual(calc.evaluate('888'),888)
self.assertEqual(calc.evaluate('12345'),12345)
self.assertEqual(calc.evaluate('11111111'),11111111)
self.assertEqual(calc.evaluate('00'),00)
from random import randint
from calc import evaluate
#1. Generate equation
x = randint(0, 9)
y = randint(0, 9)
error = randint(-1, 1)
r = evaluate("+", x, y) + error
print(f"{x} + {y} = {r}")
if error == 0:
r = True
else:
r = False
while True:
user_answer = input("(Y/N)? ").upper()
if user_answer == "Y":
user_answer = True
if user_answer == r:
print("Yay!")
break
else:
print("Wrong!")
break
elif user_answer == "N":
user_answer = False
if user_answer == r:
print("Yay!")
def test_not_supported_method(self):
with self.assertRaises(ValueError):
evaluate("not_supported", 1, 2)
from random import randint,choice
from calc import evaluate
f_n = choice(["+","-","*","/"])
x = randint(0,9)
y = randint(0,9)
error = randint(-1,1)
r = evaluate(f_n,x,y) + error
# r = i + error
r_a = (error == 0)
print(f"{x}{f_n}{y}={r}")
while True:
user_choice = input("Your answer?(Y/N) ").upper()
if user_choice != "Y" and user_choice != "N":
print("Choose Y/N answer! ")
else:
break
u_a = (user_choice == "Y")
if u_a == r_a:
print("Yay!")
else:
print("Wrong!")
def test_multiple_digits(self):
self.assertEqual(calc.evaluate("99999"), 99999)
self.assertEqual(calc.evaluate("12345"), 12345)
self.assertEqual(calc.evaluate("99999"), 99999)
self.assertEqual(calc.evaluate("99"), 99)
self.assertEqual(calc.evaluate("00"), 00)
def step_impl(context):
global result
result = calc.evaluate('1+1')
def step_impl(context):
global result
result = calc.evaluate('---123')
def test_negative_numbers(self):
self.assertEqual(calc.evaluate("-123"), -123)
self.assertEqual(calc.evaluate("-1"), -1)
self.assertEqual(calc.evaluate("0"), 0)
self.assertEqual(calc.evaluate("---123"), -123)
def test_floating_numbers(self):
self.assertEqual(calc.evaluate('123.456'), 123.456)
self.assertEqual(calc.evaluate('-123.456'), -123.456)
self.assertEqual(calc.evaluate('0123.456'), 123.456)
from random import randint, choice
from calc import evaluate
phtoan = ["+", "-", "*", "/"]
op = choice(phtoan)
#1 sinh bieu thuc
x = randint(0, 9)
y = randint(0, 9)
error = randint(-1, 1)
r = evaluate(x, y, op) + error
print(f"{x} {op} {y} = {r}")
#2
user_answer = input("(Y/N)?").upper()
if user_answer == "Y":
if error == 0:
print("Yay")
else:
print("You're Wrong")
else:
if error == 0:
print("You're Wrong")
else:
print("yay")
from random import randint, choice
from calc import evaluate
#1.sinh bieu thuc
x = randint(0, 9)
y = randint(0, 9)
pt = choice(["+", "-", "*", "/"])
error = randint(-1, 1)
r = evaluate(x, y, pt) + error
print(f"{x} {pt} {y} = {r}")
user_answer = input("(Y?N)?").upper()
if user_answer == "Y":
if error == 0:
print("yay")
elif error != 0: # co the dung ham else luon
print("wrong")
elif user_answer == "N":
if error == 0:
print("wrong")
elif error != 0:
print("yay")
def test_supported_method(self):
self.assertAlmostEqual(evaluate("+", 1, 2), 3)
# print(x,"+",y,"=",r+random.randint(-1,1))
# else:
# print(x,"+",y,"=",r)
# # string formating
# # s=f"{x}+{y}={r}"
# answer=input("Choose your answer(t/f):")
# if answer=="t" and c=='1':
# print("yay")
# elif answer=="f" and c=='0':
# print("yay")
# elif answer=="t" and c=='0':
# print("nay")
# elif answer=="f" and c=='1':
# print("nay")
opr = random.choice(["+", "-", "*", "/"])
error = random.randint(-1, 1)
r = calc.evaluate(x, y, opr) + error
s = f"{x}{opr}{y}={r}"
print(s)
answer = input("y/n")
if error == 0:
if answer == "y":
print("yay")
else:
print("nay")
else:
if answer == "y":
print("nay")
else:
print("yay")
def test_evaluate(source, want):
stack = []
evaluate(source.split(), stack)
assert want == stack[-1]
def check_answer(x, y, op, result, user_choice):
real_result = evaluate(x, y, op)
if user_choice:
return real_result = result
else:
return not real_result = result
from calc import evaluate
x = int(input("x: "))
y = int(input("y: "))
s = evaluate(x, y)
print("result: ", end = "")
print(s)
def test_add_two_numbers(self):
self.assertEqual(calc.evaluate('1+1'), 2)
def test_negative_numbers(self):
self.assertEqual(calc.evaluate('-123'),-123)
self.assertEqual(calc.evaluate('-1'),-1)
self.assertEqual(calc.evaluate('0'),0)
self.assertEqual(calc.evaluate('---123'),-123)
a = int(input("Enter a:"))
b = int(input("Enter b:"))
from calc import evaluate
# print()
# if ptoan == "+":
# n = a + b
# elif ptoan == "-":
# n = a - b
# elif ptoan == "*":
# n =a*b
# else:
# n =a/b
pt = input("pt: ")
n = evaluate(a,b,pt )
print(n)
def test_hexadecimal_numbers(self):
self.assertEqual(calc.evaluate('0x00'),0)
self.assertEqual(calc.evaluate('0x10'),16)
self.assertEqual(calc.evaluate('0xff'),255)
self.assertEqual(calc.evaluate('0xFF'),255)
#!/usr/bin/env python3
import sys
import calc
input = " ".join(sys.argv[1:])
if len(input) == 0:
exit(0)
eval_result = calc.evaluate(input)
info = ""
first_32_code_names = [
"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK", "BEL", "BS", "TAB", "LF",
"VT", "FF", "CR", "SO", "SI", "DLE", "DC1", "DC2", "DC3", "DC4", "NAK",
"SYN", "ETB", "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"
]
def get_info(number):
if isinstance(number, int) or number.is_integer():
integer = int(number)
if integer >= ord(" ") and integer <= ord("~"):
return chr(integer)
elif integer >= 0 and integer <= 31:
return "｢" + first_32_code_names[integer] + "｣"
elif integer == 127:
return "｢DEL｣"
else:
from calc import evaluate
x = int(input("x = "))
y = int(input("y = "))
pt = input("pt: ")
r = evaluate(x, y, pt)
# if pt == "+":
# r= x + y
# elif pt == "-":
# r = x -y
# elif pt =="*":
# r=x*y
# elif pt == "/":
# r=x/y
print(r)
def test_evaluate(source, want):
result = evaluate(tokenize(source))
assert want == result
def test_negative_numbers(self):
self.assertEqual(calc.evaluate('-123'), -123)
self.assertEqual(calc.evaluate('-1'), -1)
self.assertEqual(calc.evaluate('0'), 0)
self.assertEqual(calc.evaluate('---123'), -123)
self.assertEqual(calc.evaluate('-----123'), -123)
#!/usr/bin/env python3 import sys import calc input = " ".join(sys.argv[1:]) print(calc.evaluate(input), end="")
def test_hexadecimal_numbers(self):
self.assertEqual(calc.evaluate('0x00'), 0)
self.assertEqual(calc.evaluate('0x10'), 16)
self.assertEqual(calc.evaluate('0xff'), 255)
self.assertEqual(calc.evaluate('0xFF'), 255)
def test_single_hex_to_decimal(self):
i = 0
for c in "0123456789ABCDEF":
self.assertEqual(calc.evaluate("0x" + c), i)
i += 1
def test_single_digit(self):
i = 0
for c in '0123456789':
self.assertEqual(calc.evaluate(c), i)
i = i + 1
#!/usr/bin/env python3 import sys import calc input = " ".join(sys.argv[1:]) print(calc.to_bin(calc.evaluate(input)), end="")
