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)))