Design a calculator with functions and loops

You’ve learned to write functions and control loops separately — but combining them into a single, reusable tool is where real programming power begins. A calculator that runs forever until the user quits, performs addition, subtraction, multiplication, and division, and handles errors gracefully, is the perfect practical project to lock in those concepts. This lesson walks you through designing exactly that: a menu-driven calculator powered by functions and a while loop, so you can see how these building blocks work together in production-like code.

The problem this lesson solves

Most beginners know how to define a function and write a for loop, but struggle to orchestrate multiple operations in a single running program. A static script that runs once and exits doesn’t teach you about state, user interaction, or input validation. Without a loop, you can’t offer repeated calculations. Without functions, the logic becomes a tangled mess of duplicated if/elif blocks. The pain is real: you build a calculator, but it crashes on division by zero, loops forever on invalid input, or scoffs at the user with a confusing traceback.

What you need is a portable, error-resistant calculator that: - Accepts user choices from a menu. - Performs the selected operation using a dedicated function. - Loops until the user explicitly quits. - Gracefully handles division by zero and non-numeric input.

This is not just about math — it’s about designing reusable, maintainable Python code.

Core concept / mental model

Think of the calculator as a restaurant: - The menu is displayed to the user (list of operations). - The customer (user) picks an option. - The kitchen (a dedicated function) executes the order. - The waiter (the main loop) keeps the conversation going until the customer says “check, please.”

In technical terms: - A function wraps a single operation (add, subtract, multiply, divide). - A while loop keeps the program alive until the user chooses to exit. - Conditionals (if/elif/else) map the user’s choice to the correct function. - Input validation ensures the program doesn’t crash on garbage data.

This separation of concerns — logic inside functions, control flow in the loop — is the foundation of any robust script, from a CLI tool to a web server.

How it works step by step

1. Define four arithmetic functions — one for each operation. Each function takes two numbers and returns a result. Keep them pure: they only compute, no printing.
2. Create a menu string — display available options: 1. Add, 2. Subtract, 3. Multiply, 4. Divide, 5. Exit.
3. Start an infinite while loop — on each iteration: - Print the menu. - Get the user’s choice. - If choice is 5, break out of the loop and say goodbye. - Otherwise, prompt for two numbers. Use a try/except to catch bad input. - Call the appropriate function and print the result.
4. Handle division by zero — inside the divide function, check if the second number is zero and return an error message or raise an exception.
5. Keep the loop going — after showing the result, the loop restarts. The user can keep calculating until they exit.

This step-by-step mirrors what you’ll write in the hands-on section.

Hands-on walkthrough

Step 1: Define the operation functions

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 "Error: Division by zero is not allowed."
    return a / b

Pro tip: Returning a string error instead of crashing keeps your loop alive. The caller can print the message and continue.

Step 2: Build the main program with a loop

def calculator():
    print("Welcome to the Python calculator!")
    while True:
        print("\n--- Menu ---")
        print("1. Add")
        print("2. Subtract")
        print("3. Multiply")
        print("4. Divide")
        print("5. Exit")

        choice = input("Choose an option (1-5): ")

        if choice == "5":
            print("Goodbye!")
            break

        if choice not in ["1", "2", "3", "4"]:
            print("Invalid choice. Please select 1-5.")
            continue

        try:
            num1 = float(input("Enter first number: "))
            num2 = float(input("Enter second number: "))
        except ValueError:
            print("Invalid input. Please enter numbers.")
            continue

        if choice == "1":
            result = add(num1, num2)
        elif choice == "2":
            result = subtract(num1, num2)
        elif choice == "3":
            result = multiply(num1, num2)
        elif choice == "4":
            result = divide(num1, num2)

        print(f"Result: {result}")

if __name__ == "__main__":
    calculator()

Expected output (user interaction):

Welcome to the Python calculator!

--- Menu ---
1. Add
2. Subtract
3. Multiply
4. Divide
5. Exit
Choose an option (1-5): 1
Enter first number: 10
Enter second number: 5
Result: 15.0

--- Menu ---
...

Step 3: Add keyboard interrupt handling (advanced)

If the user presses Ctrl+C, the default behavior raises KeyboardInterrupt. You can catch it to exit gracefully:

def calculator():
    try:
        # ... loop content as above ...
    except KeyboardInterrupt:
        print("\nCalculator terminated by user. Goodbye!")
        sys.exit(0)

Compare options / when to choose what

When to choose the function-per-operation pattern: - You want to enforce single responsibility. - You plan to unit-test each operation independently. - You expect to add more complex operations (e.g., exponent, modulo) later.

When to avoid it: - For a one-off script with only two operations — just inline the logic. - When performance of many tiny function calls matters in a tight loop (rare in CLI apps).

Troubleshooting & edge cases

1. Infinite loop on invalid input

Problem: If the user enters a non-numeric string, float() raises ValueError and the program crashes.

Fix: Wrap float(input(...)) in a try/except ValueError block and use continue to restart the loop. The example above already does this.

2. Division by zero crashes the program

Problem: divide(10, 0) raises ZeroDivisionError.

Fix: As shown, check for b == 0 inside divide() and return an error string. Then print that string as the result. Alternatively, raise a custom exception and catch it at the call site.

3. User enters a menu choice beyond 5

Problem: The if choice not in ["1", "2", "3", "4"] block triggers even for "5" (which is valid for exit). The code avoids this by checking choice == "5" first. Always order checks from most specific to general.

4. Floating point precision issues

Problem: 0.1 + 0.2 yields 0.30000000000000004.

Solution: Use round(result, 2) when displaying, or Decimal from the decimal module for exact arithmetic (e.g., financial apps).

from decimal import Decimal, ROUND_HALF_UP

def add_precise(a, b):
    return float(Decimal(str(a)) + Decimal(str(b)))

Pro tip: Floating-point errors are a Python fundamental. For a design a calculator with functions and loops project, rounding to two decimal places is often sufficient.

What you learned & what's next

You now know how to: - Explain the core idea behind combining functions and loops to build a persistent, user-friendly tool. - Complete a practical exercise — a full-featured calculator that handles input errors, division by zero, and user quit. - Connect these patterns to larger projects: any CLI menu (e.g., a task manager, a quiz game, a database query tool) uses the same structure.

Next step: Extend the calculator with a history feature that stores past calculations using a list, and add an option to view the history. That will introduce state management and list manipulation — the next logical milestone in your Python journey.

Practice these ideas by modifying the calculator to support exponentiation (**) and a modulo operation (%). You'll reinforce the pattern and get comfortable extending function-based code.