import sys
import calculator_1
str1 = "Usage: ./100-my_calculator.py <a> <operator> <b>"
str2 = "Unknown operator. Available operators: +, -, * and /"
num = (len(sys.argv))
if num != 4:
print("{}".format(str1))
exit(1)
if sys.argv[2] not in "+-*/":
print("{}".format(str2))
exit(1)
a = int(sys.argv[1])
b = int(sys.argv[3])
if sys.argv[2] == "+":
result = calculator_1.add(a, b)
if sys.argv[2] == "-":
result = calculator_1.sub(a, b)
if sys.argv[2] == "*":
result = calculator_1.mul(a, b)
if sys.argv[2] == "/":
result = calculator_1.div(a, b)
print("{:d} {} {:d} = {:d}".format(a, sys.argv[2], b, result))
#!/usr/bin/python3
if __name__ == "__main__":
import sys
import calculator_1
n = 0
n = len(sys.argv)
if n == 4:
a = int(sys.argv[1])
b = sys.argv[2]
c = int(sys.argv[3])
print("{} {} {}".format(a, b, c), end=' ')
if sys.argv[2] == '+':
print("= {}".format(calculator_1.add(a, c)))
elif sys.argv[2] == '*':
print("= {}".format(calculator_1.mul(a, c)))
elif sys.argv[2] == '-':
print("= {}".format(calculator_1.sub(a, c)))
elif sys.argv[2] == '/':
print("= {}".format(calculator_1.div(a, c)))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
else:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
#!/usr/bin/python3
if __name__ == "__main__":
from calculator_1 import add, sub, mul, div
import sys
if len(sys.argv) != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
a = int(sys.argv[1])
b = int(sys.argv[3])
if sys.argv[2] == "+":
print("{} {} {} = {}".format(a, sys.argv[2], b, add(a, b)))
elif sys.argv[2] == "-":
print("{} {} {} = {}".format(a, sys.argv[2], b, sub(a, b)))
elif sys.argv[2] == "*":
print("{} {} {} = {}".format(a, sys.argv[2], b, mul(a, b)))
elif sys.argv[2] == "/":
print("{} {} {} = {}".format(a, sys.argv[2], b, div(a, b)))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
#!/usr/bin/python3
if __name__ == "__main__":
from calculator_1 import add, sub, mul, div
from sys import argv, exit
if (len(argv) is not 4):
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
a = int(argv[1])
b = int(argv[3])
c = add(a, b)
d = sub(a, b)
e = mul(a, b)
f = div(a, b)
if argv[2] is '+':
print("{:d} + {:d} = {:d}".format(a, b, c))
elif argv[2] is '-':
print("{:d} - {:d} = {:d}".format(a, b, d))
elif argv[2] is '/':
print("{:d} / {:d} = {:d}".format(a, b, f))
elif argv[2] is "*":
print("{:d} * {:d} = {:d}".format(a, b, e))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
#!/usr/bin/python3
from calculator_1 import add, sub, mul, div
from sys import argv, exit
if __name__ == "__main__":
if len(argv) != 4:
print('Usage: ./100-my_calculator.py <a> <operator> <b>')
exit(1)
else:
a = int(argv[1])
b = int(argv[3])
if argv[2] == "+":
print('{:d} + {:d} = {:d}'.format(a, b, add(a, b)))
elif argv[2] == '-':
print('{:d} - {:d} = {:d}'.format(a, b, sub(a, b)))
elif argv[2] == '*':
print('{:d} * {:d} = {:d}'.format(a, b, mul(a, b)))
elif argv[2] == '/':
print('{:d} / {:d} = {:d}'.format(a, b, div(a, b)))
else:
print('Unknown operator. Available operators: +, -, * and /')
exit(1)
#!/usr/bin/python3
if __name__ == "__main__":
import sys
import calculator_1
if (len(sys.argv) == 4):
operator = sys.argv[2]
a = int(sys.argv[1])
b = int(sys.argv[3])
if (operator == "+"):
print("{} + {} = {}".format(a, b, calculator_1.add(a, b)))
elif (operator == "-"):
print("{} - {} = {}".format(a, b, calculator_1.sub(a, b)))
elif (operator == "*"):
print("{} * {} = {}".format(a, b, calculator_1.mul(a, b)))
elif (operator == "/"):
print("{} / {} = {}".format(a, b, calculator_1.div(a, b)))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
else:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
#!/usr/bin/python3
if __name__ == '__main__':
import calculator_1 as calc
a = 10
b = 5
print("{} + {} = {}".format(a, b, calc.add(a, b)))
print("{} - {} = {}".format(a, b, calc.sub(a, b)))
print("{} * {} = {}".format(a, b, calc.mul(a, b)))
print("{} / {} = {}".format(a, b, calc.div(a, b)))
#!/usr/bin/python3
if __name__ == "__main__":
from sys import argv
from calculator_1 import add, sub, mul, div
l = len(argv)
r = 0
if l != 4:
print('Usage: ./100-my_calculator.py <a> <operator> <b>')
exit(1)
else:
a = int(argv[1])
b = int(argv[3])
if argv[2] == '+':
r = add(a, b)
print('{:d} + {:d} = {:d}'.format(a, b, r))
elif argv[2] == '-':
r = sub(a, b)
print('{:d} - {:d} = {:d}'.format(a, b, r))
elif argv[2] == '*':
r = mul(a, b)
print('{:d} * {:d} = {:d}'.format(a, b, r))
elif argv[2] == '/':
r = div(a, b)
print('{:d} / {:d} = {:d}'.format(a, b, r))
else:
print('Unknown operator. Available operators: +, -, * and /')
exit(1)
#!/usr/bin/python3
if __name__ == "__main__":
a = 10
b = 5
import calculator_1 as cal
print('{} + {} = {}'.format(a, b, cal.add(int(a), int(b))))
print('{} - {} = {}'.format(a, b, cal.sub(int(a), int(b))))
print('{} * {} = {}'.format(a, b, cal.mul(int(a), int(b))))
print('{} / {} = {}'.format(a, b, cal.div(int(a), int(b))))
#!/usr/bin/python3
if __name__ == "__main__":
from sys import argv
from calculator_1 import add, sub, mul, div
length = len(argv)
if length != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
else:
a = int(argv[1])
b = int(argv[3])
if argv[2] == '+':
print("{} + {} = {}".
format(a, b, add(a, b)))
elif argv[2] == '-':
print("{} - {} = {}".
format(a, b, sub(a, b)))
elif argv[2] == '*':
print("{} * {} = {}".
format(a, b, mul(a, b)))
elif argv[2] == '/':
print("{} / {} = {}".
format(a, b, div(a, b)))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
#!/usr/bin/python3
if __name__ == "__main__":
from calculator_1 import add, sub, mul, div
from sys import argv
if len(argv) != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
else:
op = argv[2]
if op != "+" and op != "-" and op != "*" and op != "/":
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
else:
a = argv[1]
b = argv[3]
ai = int(a, 10)
bi = int(b, 10)
if argv[2] is "+":
res = add(ai, bi)
elif argv[2] is "-":
res = sub(ai, bi)
elif argv[2] is "*":
res = mul(ai, bi)
elif argv[2] is "/":
res = div(ai, bi)
print("{:d} {} {:d} = {:d}".format(ai, argv[2], bi, res))
#!/usr/bin/python3
if __name__ == "__main__":
import sys
from calculator_1 import add, sub, mul, div
if len(sys.argv) != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
op = "+-*/"
if sys.argv[2] not in op:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
print("{} {} {} = ".format(sys.argv[1], sys.argv[2], sys.argv[3]), end="")
ope = sys.argv[2]
a = int(sys.argv[1])
b = int(sys.argv[3])
if ope == '+':
print("{}".format(add(a, b)))
elif ope == '-':
print("{}".format(sub(a, b)))
elif ope == '*':
print("{}".format(mul(a, b)))
else:
print("{}".format(div(a, b)))
#!/usr/bin/python3
from calculator_1 import add, sub, mul, div
from sys import argv, exit
if __name__ == "__main__":
if len(argv) != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
if argv[2] != "+" and argv[2] != "-" and argv[2] != "*" and argv[2] != "/":
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
a = int(argv[1])
b = int(argv[3])
if argv[2] == "+":
calc = add(a, b)
if argv[2] == "-":
calc = sub(a, b)
if argv[2] == "*":
calc = mul(a, b)
if argv[2] == "/":
calc = div(a, b)
print("{} {} {} = {}".format(a, argv[2], b, calc))
#!/usr/bin/python3
if __name__ == "__main__":
from calculator_1 import add, sub, mul, div
a = 10
b = 5
print("{0:d} + {1:d} = {2:d}".format(a, b, add(a, b)))
print("{0:d} - {1:d} = {2:d}".format(a, b, sub(a, b)))
print("{0:d} * {1:d} = {2:d}".format(a, b, mul(a, b)))
print("{0:d} / {1:d} = {2:d}".format(a, b, div(a, b)))
#!/usr/bin/python3
if __name__ == "__main__":
from sys import argv
from calculator_1 import add, sub, mul, div
if len(argv) != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
a = int(argv[1])
b = int(argv[3])
operator = argv[2]
if operator == "+":
print("{} {} {} = {}".format(a, operator, b, add(a, b)))
elif operator == '-':
print("{} {} {} = {}".format(a, operator, b, sub(a, b)))
elif operator == "*":
print("{} {:s} {} = {}".format(a, operator, b, mul(a, b)))
elif operator == '/':
print("{} {} {} = {}".format(a, operator, b, div(a, b)))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
#!/usr/bin/python3
if __name__ == '__main__':
from calculator_1 import add, sub, mul, div
import sys as s
operators = '+-*/'
if (len(s.argv) is 4 and (s.argv[2] in operators)):
op1 = int(s.argv[1])
op2 = int(s.argv[3])
if (operators[0] is s.argv[2]):
print('{:d} + {:d} = {:d}'.format(op1, op2, add(op1, op2)))
if (operators[1] is s.argv[2]):
print('{:d} - {:d} = {:d}'.format(op1, op2, sub(op1, op2)))
if (operators[2] is s.argv[2]):
print('{:d} * {:d} = {:d}'.format(op1, op2, mul(op1, op2)))
if (operators[3] is s.argv[2]):
print('{:d} / {:d} = {:d}'.format(op1, op2, div(op1, op2)))
else:
if (len(s.argv) is 4):
print('Unknown operator. Available operators: +, -, * and /')
else:
print('Usage: {} <a> <operator> <b>'.format(s.argv[0]))
exit(1)
#!/usr/bin/python3
from calculator_1 import add, sub, mul, div
from sys import argv
if __name__ == "__main__":
argc = len(argv) - 1
op = ''
if argc != 3:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
num1 = int(argv[1])
op = argv[2]
num2 = int(argv[3])
if op == '+':
print("{:d} {} {:d} = {:d}".format(num1, op, num2, add(num1, num2)))
elif op == '-':
print("{:d} {} {:d} = {:d}".format(num1, op, num2, sub(num1, num2)))
elif op == '*':
print("{:d} {} {:d} = {:d}".format(num1, op, num2, mul(num1, num2)))
elif op == '/':
print("{:d} {} {:d} = {:d}".format(num1, op, num2, div(num1, num2)))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
if __name__ == "_main__":
from calculator_1 import add, sub, mul, div
from sys import argv
ac = len(argv)
if ac != 3:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
a = int(argv[1])
operator = int(argv[2])
b = int(argv[3])
if operator != '+':
result = add(a, b)
elif operator != '-':
result = sub(a, b)
elif operator != '*':
result = mul(a, b)
elif operator != '/':
result = div(a, b)
else:
print("Unknown operator. Available operators: +, -, * and /")
print("{:d} {} {:d} = {:d}".format(a, operator, b, result))
#!/usr/bin/python3
from calculator_1 import add, sub, mul, div
from sys import argv, exit
if __name__ == '__main__':
if len(argv) != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
else:
a = int(argv[1])
b = int(argv[3])
if argv[2] == '+':
print("{} {} {} = {}".format(argv[1], argv[2], argv[3], add(a, b)))
elif argv[2] == '-':
print("{} {} {} = {}".format(argv[1], argv[2], argv[3], sub(a, b)))
elif argv[2] == '*':
print("{} {} {} = {}".format(argv[1], argv[2], argv[3], mul(a, b)))
elif argv[2] == '/':
print("{} {} {} = {}".format(argv[1], argv[2], argv[3], div(a, b)))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
#!/usr/bin/python3
if __name__ == "__main__":
from sys import argv
from calculator_1 import add, sub, mul, div
if len(argv) != 4:
print(
"{:s}".format("Usage: ./100-my_calculator.py <a> <operator> <b>"))
exit(1)
elif argv[2] == '+':
print("{:d} {:s} {:d} = {:d}".format(int(argv[1]), argv[2],
int(argv[3]),
add(int(argv[1]), int(argv[3]))))
elif argv[2] == '-':
print("{:d} {:s} {:d} = {:d}".format(int(argv[1]), argv[2],
int(argv[3]),
sub(int(argv[1]), int(argv[3]))))
elif argv[2] == '*':
print("{:d} {:s} {:d} = {:d}".format(int(argv[1]), argv[2],
int(argv[3]),
mul(int(argv[1]), int(argv[3]))))
elif argv[2] == '/':
print("{:d} {:s} {:d} = {:d}".format(int(argv[1]), argv[2],
int(argv[3]),
div(int(argv[1]), int(argv[3]))))
else:
print("{:s}".format(
"Unknown operator. Available operators: +, -, * and /"))
exit(1)
#!/usr/bin/python3
if __name__ == "__main__":
from calculator_1 import add, sub, mul, div
from sys import argv
if len(argv) != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
op = argv[2]
num1 = int(argv[1])
num2 = int(argv[3])
if op is '+':
print("{:d} + {:d} = {:d}".format(num1, num2, add(num1, num2)))
elif op is '-':
print("{:d} - {:d} = {:d}".format(num1, num2, sub(num1, num2)))
elif op is '*':
print("{:d} * {:d} = {:d}".format(num1, num2, mul(num1, num2)))
elif op is '/':
print("{:d} / {:d} = {:d}".format(num1, num2, div(num1, num2)))
else:
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
#!/usr/bin/python3
if __name__ == "__main__":
from calculator_1 import add, sub, mul, div
import sys
argv = sys.argv
len = len(argv)
if len != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
sys.exit(1)
a = int(argv[1])
b = int(argv[3])
op = argv[2]
if op != "+" and op != "-" and op != "*" and op != "/":
print("Unknown operator. Available operators: +, -, * and /")
sys.exit(1)
if op == "+":
print("{:d} {:s} {:d} = {:d}".format(a, op, b, add(a, b)))
if op == "-":
print("{:d} {:s} {:d} = {:d}".format(a, op, b, sub(a, b)))
if op == "*":
print("{:d} {:s} {:d} = {:d}".format(a, op, b, mul(a, b)))
if op == "/":
print("{:d} {:s} {:d} = {:d}".format(a, op, b, div(a, b)))
#!/usr/bin/python3
from sys import argv
from calculator_1 import add, sub, mul, div
if __name__ == '__main__':
opr = {'+', '-', '*', '/'}
if len(argv) < 4:
print('Usage: ./100-my_calculator.py <a> <operator> <b>')
exit(1)
elif argv[2] in opr:
a = int(argv[1])
b = int(argv[3])
if argv[2] == '+':
print('{} {} {} = {}'.format(a, argv[2], b, add(a, b)))
elif argv[2] == '-':
print('{} {} {} = {}'.format(a, argv[2], b, sub(a, b)))
elif argv[2] == '*':
print('{} {} {} = {}'.format(a, argv[2], b, mul(a, b)))
else:
print('{} {} {} = {}'.format(a, argv[2], b, div(a, b)))
else:
print('Unknown operator. Available operators: +, -, * and /')
exit(1)
#!/usr/bin/python3
from calculator_1 import add, sub, mul, div
if __name__ == '__main__':
a = 10
b = 5
print('{} + {} = {}'.format(a, b, add(a, b)))
print('{} - {} = {}'.format(a, b, sub(a, b)))
print('{} * {} = {}'.format(a, b, mul(a, b)))
print('{} / {} = {}'.format(a, b, div(a, b)))
#!/usr/bin/python3
if __name__ == "__main__":
from calculator_1 import add, sub, mul, div
import sys
if len(sys.argv) != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
operator = sys.argv[2]
if operator not in '*+-/':
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
a = sys.argv[1]
b = sys.argv[3]
if operator == '+':
result = add(int(a), int(b))
elif operator == '-':
result = sub(int(a), int(b))
elif operator == '*':
result = mul(int(a), int(b))
else:
result = div(int(a), int(b))
print("{} {} {} = {}".format(a, operator, b, result))
#!/usr/bin/python3
if __name__ == '__main__':
from calculator_1 import add, sub, mul, div
import sys
ar = sys.argv
lenAv = len(sys.argv)
if lenAv != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
sys.exit(1)
if ar[2] != '+' and ar[2] != '-' and ar[2] != '*' and ar[2] != '/':
print("Unknown operator. Available operators: +, -, * and /")
sys.exit(1)
a = int(ar[1])
b = int(ar[3])
if ar[2] == '+':
print(a, ar[2], b, "=", add(a, b))
if ar[2] == '-':
print(a, ar[2], b, "=", sub(a, b))
if ar[2] == '*':
print(a, ar[2], b, "=", mul(a, b))
if ar[2] == '/':
print(a, ar[2], b, "=", div(a, b))
#!/usr/bin/python3
from calculator_1 import add, sub, mul, div
if __name__ == "__main__":
import sys
argc = len(sys.argv)
args = sys.argv
if argc != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
if args[2] != "+" and args[2] != "-" and args[2] != "*" and args[2] != "/":
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
a = int(args[1])
b = int(args[3])
if args[2] == '+':
print("{} + {} = {}".format(a, b, add(a, b)))
elif args[2] == '-':
print("{} - {} = {}".format(a, b, sub(a, b)))
elif args[2] == '*':
print("{} * {} = {}".format(a, b, mul(a, b)))
elif args[2] == '/':
print("{} / {} = {}".format(a, b, div(a, b)))
if __name__ == "__main__":
import sys
from calculator_1 import add, sub, mul, div
myArgs = sys.argv
if len(myArgs) != 4:
print('Usage: ./100-my_calculator.py <a> <operator> <b>')
exit(1)
else:
a = int(myArgs[1])
b = int(myArgs[3])
operator = myArgs[2]
if operator not in ['+', '-', '*', '/']:
print('Unknown operator. Available operators: +, -, * and /')
exit(1)
if operator == '+':
print('{} {} {} = {}'.format(a, operator, b, add(a, b)))
if operator == '-':
print('{} {} {} = {}'.format(a, operator, b, sub(a, b)))
if operator == '*':
print('{} {} {} = {}'.format(a, operator, b, mul(a, b)))
if operator == '/':
print('{} {} {} = {}'.format(a, operator, b, div(a, b)))
#!/usr/bin/python3
if __name__ == "__main__":
from calculator_1 import add, sub, mul, div
a = 10
b = 5
print("{:d} + {:d} = {:d}".format(a, b, add(a, b)))
print("{:d} - {:d} = {:d}".format(a, b, sub(a, b)))
print("{:d} * {:d} = {:d}".format(a, b, mul(a, b)))
print("{:d} / {:d} = {:d}".format(a, b, div(a, b)))
#!/usr/bin/python3
from calculator_1 import add, sub, mul, div
from sys import argv
if __name__ == "__main__":
l = len(argv)
if l != 4:
print("Usage: ./100-my_calculator.py <a> <operator> <b>")
exit(1)
op = argv[2]
if op != '-' and op != '+' and op != '*' and op != '/':
print("Unknown operator. Available operators: +, -, * and /")
exit(1)
a = int(argv[1])
b = int(argv[3])
if op == '+':
print("{} {} {} = {}".format(a, op, b, add(a, b)))
elif op == '-':
print("{} {} {} = {}".format(a, op, b, sub(a, b)))
elif op == '/':
print("{} {} {} = {}".format(a, op, b, div(a, b)))
else:
print("{} {} {} = {}".format(a, op, b, mul(a, b)))
