Want to enhance your Python skills by building a useful project? In this tutorial, we’ll create a Python calculator that performs essential arithmetic operations, exponentiation, and includes memory recall/clearing functionality.
This beginner-friendly project introduces important programming concepts such as:
- Handling user input and validation
- Using functions for modular programming
- Implementing loops and conditional statements
- Storing and managing a simple memory feature
By the end, you’ll have a fully functional calculator that you can use in your terminal. Let’s get started!
Step 1: Setting Up the Project
Before we start coding, let’s set up our Python project:
1. Make sure Python is installed on your computer. If not, download it from the official Python website.
2. Open your favorite code editor or IDE.
3. Create a new Python file, for example, calculator.py
.
Great, now, let's dive head first into our Python editor to get this build started.
Step 2: Understanding How the Calculator Works
Our command line calculator will perform the following tasks:
- Prompt the user to select an operation: addition, subtraction, multiplication, division, or exponentiation.
- Ask the user to input two numbers.
- Perform the selected operation and display the result.
- Allow the user to store a result in memory and recall or clear it.
- Continue running until the user decides to exit.
Step 3: Writing the Calculator Functions
Now, let’s define the functions that handle each arithmetic operation.
# Basic Arithmetic 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):
return a / b if b != 0 else 'Error: Division by zero'
def exponentiate(a, b):
return a ** b
How It Works:
-
Each function takes two numbers and performs the corresponding operation.
-
The
divide()
function checks for division by zero and prevents errors. -
This modular approach makes our calculator easy to expand and maintain.
Breaking It Down Further:
Using Functions for Clean Code
Each operation is wrapped in a function, making the code modular and reusable.
Handling Division by Zero Gracefully
def divide(a, b):
return a / b if b != 0 else 'Error: Division by zero'
-
If
b
is zero, the function returns an error message instead of causing a crash.
Keeping the Code Readable with Clear Naming
Function names like add()
, subtract()
, and multiply()
make the code self-explanatory, improving readability and maintainability.
Now that we have our core functions ready, let’s move on to memory storage.
Step 4: Implementing Memory Functions
We’ll include a simple memory system that lets users store and recall the last result.
# Memory Storage
memory = None
def store_memory(value):
global memory
memory = value
print("Stored in memory.")
def recall_memory():
return memory if memory is not None else "No value in memory."
def clear_memory():
global memory
memory = None
print("Memory cleared.")
How It Works:
-
store_memory()
saves the last result in memory. -
recall_memory()
retrieves the stored value or notifies if memory is empty. -
clear_memory()
erases stored values. -
This allows users to work with previous results without needing to re-enter numbers.
Why Do We Use a Global Variable?
The memory
variable is defined outside any function, making it global so that multiple functions can access and modify it. This allows:
-
Consistent data storage: The stored value remains available across different function calls.
-
Ease of use: Users can store, recall, and clear memory seamlessly.
-
Global scope necessity: Without using
global
, each function would treatmemory
as a local variable, meaning changes wouldn’t persist between function calls.
By using global memory
, we ensure that the stored value is maintained across different user interactions.
Now that we have memory management in place, let’s proceed to handle user input and execute calculations.
Step 5: User Input and Running the Calculator
Now, let’s build the main while loop that manages user input, executes calculations, and interacts with memory storage.
# Main Calculator Loop
def calculator():
while True:
print("\nSimple Calculator")
print("Select operation:")
print("1. Addition (+)")
print("2. Subtraction (-)")
print("3. Multiplication (*)")
print("4. Division (/)")
print("5. Exponentiation (^)")
print("6. Recall Memory (M)")
print("7. Clear Memory (MC)")
print("8. Exit (X)")
choice = input("Enter choice: ").strip().lower()
if choice in ['x', '8']:
print("Exiting calculator. Goodbye!")
break
elif choice in ['m', '6']:
print("Memory: ", recall_memory())
continue
elif choice in ['mc', '7']:
clear_memory()
continue
if choice not in ['1', '2', '3', '4', '5', '+', '-', '*', '/', '^']:
print("Invalid input. Try again.")
continue
try:
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
except ValueError:
print("Invalid number. Please enter numeric values.")
continue
if choice in ['1', '+']:
result = add(num1, num2)
elif choice in ['2', '-']:
result = subtract(num1, num2)
elif choice in ['3', '*']:
result = multiply(num1, num2)
elif choice in ['4', '/']:
result = divide(num1, num2)
elif choice in ['5', '^']:
result = exponentiate(num1, num2)
print("Result: ", result)
store_option = input("Store result in memory? (y/n): ").strip().lower()
if store_option == 'y':
store_memory(result)
How It Works:
- The user selects an operation.
- Numbers are taken as input and converted to floats.
- A function is called based on user selection.
- The result is displayed and can be stored in memory.
- The loop continues until the user exits.
Breaking It Down Further:
Continuous Execution with a While Loop
The loop ensures that the calculator runs continuously until the user decides to exit.
Input Handling and Validation
-
Users are prompted to enter a valid choice.
-
Numeric values are validated to prevent errors.
Memory Interaction
-
Users can recall (
M
) or clear (MC
) stored values at any time. -
The calculator allows saving results for reuse.
By structuring our main loop this way, we create a user-friendly experience while maintaining robust error handling.
Step 6: Running the Calculator
To make sure our program runs correctly, we use:
if __name__ == '__main__':
calculator()
Why Is This Needed?
-
Direct Execution: Ensures the script runs only when executed directly, not when imported as a module.
-
Best Practices: Following this pattern allows for future code expansion while maintaining clarity.
-
Encapsulation: Keeps the calculator function separate from execution logic, improving code organization.
By adding this simple if __name__ == '__main__':
check, we make our code more scalable and reusable in larger projects.
Final Code: Calculator
# Basic Arithmetic 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):
return a / b if b != 0 else 'Error: Division by zero'
def exponentiate(a, b):
return a ** b
# Memory Storage
memory = None
def store_memory(value):
"""Stores the last calculated result in memory."""
global memory
memory = value
print("Stored in memory.")
def recall_memory():
"""Retrieves the last stored value from memory."""
return memory if memory is not None else "No value in memory."
def clear_memory():
"""Clears the stored value in memory."""
global memory
memory = None
print("Memory cleared.")
# Main Calculator Loop
def calculator():
while True:
print("\nSimple Calculator")
print("Select operation:")
print("1. Addition (+)")
print("2. Subtraction (-)")
print("3. Multiplication (*)")
print("4. Division (/)")
print("5. Exponentiation (^)")
print("6. Recall Memory (M)")
print("7. Clear Memory (MC)")
print("8. Exit (X)")
choice = input("Enter choice: ").strip().lower()
if choice in ['x', '8']:
print("Exiting calculator. Goodbye!")
break
elif choice in ['m', '6']:
print("Memory: ", recall_memory())
continue
elif choice in ['mc', '7']:
clear_memory()
continue
if choice not in ['1', '2', '3', '4', '5', '+', '-', '*', '/', '^']:
print("Invalid input. Try again.")
continue
try:
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
except ValueError:
print("Invalid number. Please enter numeric values.")
continue
if choice in ['1', '+']:
result = add(num1, num2)
elif choice in ['2', '-']:
result = subtract(num1, num2)
elif choice in ['3', '*']:
result = multiply(num1, num2)
elif choice in ['4', '/']:
result = divide(num1, num2)
elif choice in ['5', '^']:
result = exponentiate(num1, num2)
print("Result: ", result)
store_option = input("Store result in memory? (y/n): ").strip().lower()
if store_option == 'y':
store_memory(result)
# Ensures the script runs correctly when executed directly
if __name__ == '__main__':
calculator()
Wrapping Up
Congratulations! You’ve built a fully functional command line calculator in Python.
This project helped you learn:
- User input handling and validation
- Functions for modular programming
- Loops for continuous execution
- Conditional statements for decision-making
- Implementing a simple memory storage system
Next Steps: Enhance Your Calculator!
- Add support for square root and logarithms.
- Implement a history feature to keep track of previous calculations.
- Create a graphical user interface (GUI) using Tkinter or PyQt.
The best way to learn Python is by building fun projects — so keep experimenting!