RugvAI Labs

Mini-Project: Robust Calculator

You'll build a calculator that NEVER crashes in 20 minutes. Type "ten" instead of 10? It says "please enter a number" and asks again. Divide by zero? It explains and retries. By the end, you'll understand try/except, input validation loops, and what "graceful failure" really means.

Prerequisites

Before You Start

#What you'll build

A calculator that accepts two numbers and an operator (+, -, *, /). It survives any bad input -- non-numeric values, unknown operators, division by zero -- and gives a clear, friendly message before asking again. The user has to type "quit" to leave.

Sample interaction

text

First number: ten
That doesn't look like a number. Try again.
First number: 10
Operator (+, -, *, /): plus
Unknown operator 'plus'. Use one of: + - * /
Operator (+, -, *, /): +
Second number: 0
10.0 + 0.0 = 10.0

First number: 10
Operator (+, -, *, /): /
Second number: 0
You can't divide by zero. Try again.

First number: quit
Bye!

#What you'll learn

How to catch specific exceptions with try/except
How to loop until valid input arrives
How to compose multiple validation layers without nesting six levels deep

#Step 1: Basic calculator (will crash)

The cheerful, fragile version. Works -- as long as nobody types anything weird.

pythonrunnable cell

Input for this program

This code calls input(). Python here can't pause to ask you, so type the answers below before running — one value per line, in the order the program asks for them.

a = float(input("First number: "))
op = input("Operator: ")
b = float(input("Second number: "))

if op == "+":
    print(a + b)
elif op == "-":
    print(a - b)
elif op == "*":
    print(a * b)
elif op == "/":
    print(a / b)

Try typing ten for the first number. ValueError. Try / with b = 0. ZeroDivisionError. Try ?? for the operator. Silent nothing. We'll fix all three.

What Do You Think?

What does this raise? result = 10 / 0

The answer is ZeroDivisionError. Python refuses to silently return infinity or NaN for x / 0 — it raises a specific, named exception so you can catch it. Note that ZeroDivisionError is a subclass of ArithmeticError, so except ArithmeticError would catch it too — but catching the most specific type is always better. Floats are special: float('inf') / 0 also raises ZeroDivisionError, but 0.0 ** -1 raises it too while float('inf') + 1 happily returns inf. The takeaway: division by zero is always a Python error you must explicitly handle.

Quick check

What exception does `float('ten')` raise?

#Step 2: Catch ZeroDivisionError

Wrap the division branch in try/except. If b is 0 and the operator is /, Python raises ZeroDivisionError -- catch it and print a message.

pythonreference · read-only

try:
    print(a / b)
except ZeroDivisionError:
    print("You can't divide by zero.")

try runs the risky code. If an exception of the matching type is raised, control jumps to the except block. Code after the try/except keeps running like nothing happened.

What Do You Think?

What gets printed? try: x = int("hello") except ZeroDivisionError: print("zero") print("after")

The answer is Crashes with ValueError. The try raises ValueError (from int("hello")), but the except only catches ZeroDivisionError. Since the types don't match, the exception is NOT caught — it propagates up and crashes the program. The print("after") never runs. Lesson: except only catches the exact type (or its subclasses) you specify. If you want a broader net, use except Exception: — but never use bare except: which catches even Ctrl+C and hides real bugs.

#Step 3: Catch bad numbers

float("ten") raises ValueError. Wrap the input + conversion in try/except too.

pythonrunnable cell

Input for this program

This code calls input(). Python here can't pause to ask you, so type the answers below before running — one value per line, in the order the program asks for them.

try:
    a = float(input("First number: "))
except ValueError:
    print("That doesn't look like a number.")

Now bad input prints a message instead of crashing. But the user is dropped out of the program. To keep them in, loop until they give valid input.

Quick check

Why catch `ValueError` specifically instead of using a bare `except:` ?

#Step 4: Input validation loop

A helper that keeps asking for a number until it gets one. Returns the float when valid.

pythonrunnable cell

Input for this program

This code calls input(). Python here can't pause to ask you, so type the answers below before running — one value per line, in the order the program asks for them.

def read_number(prompt):
    while True:
        raw = input(prompt)
        if raw == "quit":
            return None
        try:
            return float(raw)
        except ValueError:
            print("That doesn't look like a number. Try again.")

while True + try/except + return is the universal "ask until valid" pattern. Returning None on "quit" lets the caller stop the main loop cleanly.

What Do You Think?

What happens here? while True: try: x = int(input()) # user types "abc" break except ValueError: print("try again")

The answer is Prints 'try again' and re-prompts forever until valid input. When int("abc") raises ValueError, the except catches it and prints "try again". Since break was never reached, the while True keeps looping — so we ask for input again. If the user finally types a valid number, int() succeeds, break fires, and the loop ends. This is the universal "keep asking until valid" pattern. Without break inside the try, even valid input would loop forever; without try/except, bad input crashes the program.

#Step 5: Validate the operator with a set

Operators are easier than numbers -- just check membership in a small set.

pythonrunnable cell

Input for this program

This code calls input(). Python here can't pause to ask you, so type the answers below before running — one value per line, in the order the program asks for them.

VALID_OPS = {"+", "-", "*", "/"}

def read_operator():
    while True:
        op = input("Operator (+, -, *, /): ").strip()
        if op in VALID_OPS:
            return op
        print(f"Unknown operator {op!r}. Use one of: + - * /")

{...} set syntax. op in VALID_OPS is O(1) lookup. {op!r} calls repr() so the message shows the operator with quotes -- helpful when the user typed something weird with spaces.

#Step 6: Glue everything into a robust main loop

pythonreference · read-only

def main():
    while True:
        a = read_number("First number: ")
        if a is None:
            break
        op = read_operator()
        b = read_number("Second number: ")
        if b is None:
            break

        try:
            if op == "+":
                result = a + b
            elif op == "-":
                result = a - b
            elif op == "*":
                result = a * b
            else:
                result = a / b
            print(f"{a} {op} {b} = {result}")
        except ZeroDivisionError:
            print("You can't divide by zero. Try again.")

    print("Bye!")

That's a calculator the user genuinely can't break. Try every kind of garbage -- it'll just ask again.

#Now build it yourself

Mini project

Calculator that never crashes

~20 min

Build a calculator that accepts two numbers and an operator (+, -, *, /). The program must NEVER crash, no matter what the user types: not on letters, not on division by zero, not on unknown operators. Bad inputs print a friendly message and re-prompt. Typing 'quit' as a number ends the program.

Expected output

First number: ten
That doesn't look like a number. Try again.
First number: 10
Operator (+, -, *, /): plus
Unknown operator 'plus'. Use one of: + - * /
Operator (+, -, *, /): +
Second number: 0
10.0 + 0.0 = 10.0

First number: 10
Operator (+, -, *, /): /
Second number: 0
You can't divide by zero. Try again.

First number: quit
Bye!

Your code

pythonrunnable cell

VALID_OPS = {"+", "-", "*", "/"}

def read_number(prompt):
  # TODO: while loop -- ask until valid float OR 'quit'
  # TODO: return None on quit, float on success
  pass

def read_operator():
  # TODO: while loop -- ask until input is in VALID_OPS
  pass

def main():
  while True:
      a = read_number("First number: ")
      if a is None:
          break
      op = read_operator()
      b = read_number("Second number: ")
      if b is None:
          break

      # TODO: compute result based on op
      # TODO: catch ZeroDivisionError for division
      # TODO: print the result

  print("Bye!")

main()

#Now make it your own

Try one of these variations:

History -- keep a list of every successful computation and show "Last 5: ..." when the user types 'history' instead of a number.
More operators -- add ** (power), % (modulo), and // (integer division). Update both VALID_OPS and the dispatch chain.
Replace if/elif with a dict -- map operators to lambda functions: OPS = {"+": lambda a, b: a + b, ...}. The dispatch becomes a single line: result = OPS[op](a, b).

#What's next

You now know how to make a program that doesn't crash on bad input. Next up: file I/O. You'll learn to read CSV, JSON, and plain text safely with with open(...), handle missing files, and save model artifacts -- the foundation of every ML pipeline that loads training data from disk.