Python Project: Calculator

What you are building

You build a four-function calculator: add, subtract, multiply, divide. Each operation is its own function. Division checks the denominator before it runs. A short list of expressions is printed so you can see every path, including the error path.

Run the examples in the Python editor at /try. That page is a Python runner, not an HTML preview and not a C or C++ compiler. Numbers are hardcoded so Run prints immediately.

Skills used

• def to name one function per operator
• return so the caller decides how to print
• if to block divide-by-zero
• float values so 12 / 5 is not truncated
• A dict that maps an operator string to a function

One function per operator

Keep the math in functions. The rest of the program only chooses which function to call. That split makes the zero check easy to find later.

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

print(add(12, 5))
print(subtract(12, 5))
print(multiply(12, 5))

Each call returns a number. Nothing prints inside the function. That is deliberate. A calculator that returns values can also be tested, logged, or formatted by the caller.

Guard divide-by-zero

Python will raise ZeroDivisionError if you write 12 / 0. Catch the bad input before the division. Return a clear signal the printer can understand. Here that signal is None.

def divide(a, b):
    if b == 0:
        return None
    return a / b

print(divide(12, 5))
print(divide(12, 0))
print(divide(9, 3))

Complete program

A list of triples holds left value, operator, right value. A dict maps each operator to a function. Unknown operators get their own message. Division by zero never crashes the run.

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

def multiply(a, b):
    return a * b

def divide(a, b):
    if b == 0:
        return None
    return a / b

OPS = {'+': add, '-': subtract, '*': multiply, '/': divide}

expressions = [
    (12, '+', 5),
    (12, '-', 5),
    (12, '*', 5),
    (12, '/', 5),
    (12, '/', 0),
    (9, '/', 3),
    (4, '%', 2),
]

print("Calculator")
print("----------")
for left, op, right in expressions:
    fn = OPS.get(op)
    if fn is None:
        print(left, op, right, "-> unknown operator")
        continue
    result = fn(left, right)
    if result is None:
        print(left, op, right, "-> cannot divide by zero")
    elif isinstance(result, float) and not result.is_integer():
        print(left, op, right, "=", round(result, 4))
    else:
        print(left, op, right, "=", result)

OPS.get(op) returns None when the key is missing, so % is handled without a KeyError. Integer-looking floats print without a trailing .0 because the branch checks is_integer().

Common mistakes

• Using // when you wanted ordinary division. 12 // 5 is 2. This project uses/ so 12 / 5 is 2.4.
• Writing if b = 0. That is assignment. The test is ==.
• Putting print inside every math function. Then you cannot reuse the same function to fill a table or a test.
• Forgetting the unknown-operator path. A typo in the expression list then raises instead of reporting.
• Mixing strings and numbers: add("12", 5) concatenates or crashes. Keep both sides asint or float.

How to extend / Practice tasks

Change the complete program. Keep the zero guard intact.

1. Add a power function for ** and register it in OPS. Print2 ** 8 as a new row.
2. Accept a leftover from integer division: add remainder(a, b) for %, still returning None when b is 0.
3. Round every printed result to two decimal places, including whole numbers such as 17.00, so the column lines up like a receipt.