In recent years, the digital world has increasingly embraced cloud systems. Services have demonstrated their convenience and reliability by instantly processing enormous amounts of information. But today, let's revisit the basics of modern technology and show you how to write a calculator program from scratch.
As we start working on the calculator, let's remember what it consists of and how it functions. We'll be creating an analog of a simple desktop calculator that every student has. By reading this article and completing all the tasks, you'll obtain readytouse Python code for a basic calculator.
A desktop calculator includes:
Buttons with digits
Buttons with mathematical operations
Display
Microchips inside
The functions of a desktop calculator include:
Addition
Subtraction
Division
Multiplication
Clearing an operation
Saving a result
Calculating a percentage
Taking the square root of a number
To understand the principles of writing a calculator, let's take the minimal set of functions from this list:
Inputting numbers
Displaying the result
Addition
Subtraction
Division
Multiplication
You can write the code directly in an online editor.
For example:
Mathematical operations we will use:
2+2
4
105
5
3*3
9
12/4
3.0
To see the result, you need to display it on the screen. For this purpose, there's a function called print()
, which displays the arguments in parentheses in the console.
print(4 * 4)
16
This function will serve as an equivalent to the display of our calculator.

To avoid performing calculations inside the print()
function, we'll store them in variables.
result = 16 / 8
Later, we can print the value of the variable to the console.
print(result)
2.0
Now that we've covered the display, let's use Python 3 to create keyboard input. We have buttons with digits on the keyboard, and to pass them to the program, we use the input()
function. When called, it reads any characters from the keyboard until the Enter key is pressed. After that, it returns the result as a string of the entered characters. Let's see how it works:
text = input() # Hi
Hi
Let's display the result on the screen.
print(text)
Hi
If you pass text into the input()
function, it is displayed on the screen before the string is read.
username = input('Enter your name: ') # John
print(username)
Enter your name: John
John
To make the output more userfriendly, we can add explanations to it. For this, we use string concatenation.
print('Hello, ' + username + '!')
Hello, John!
Another way to combine text with data is by using formatted strings. To do this, you need to place the character f
before the quotation marks, and write the data directly inside the string within curly braces. This functionality was introduced in Python version 3.6.0.
print(f'Hello, {username}!')
Hello, John!
Now that we can perform mathematical operations, read data from the keyboard, and display the result nicely in the console, let's finally write the first version of our calculator! For simplicity, let it only add numbers for now, but this will already be a complete example of a Python program.
# Read the data = input('Enter the first number: ')
b = input('Enter the second number: ')
# Perform calculations
result = a + b
# Display the result in the console
print(f'The sum of {a} and {b} is: {result}')
Enter the first number: 12
Enter the second number: 55
The sum of 12 and 55 is: 1255
Something went wrong. The numbers didn't add up; they were concatenated as text. The issue is that input()
in Python returns a string input from the keyboard, even if you entered only numbers. This behavior is more explicit, aligning with Python's philosophy: "Explicit is better than implicit." To fix this error, we'll use the function for converting a string to a number: int()
. Let's see how num int input works:
num = int(input())
print(num + 10)
32
42
Let's modify our program.
# Read the data = int(input('Enter the first number: '))
b = int(input('Enter the second number: '))
# Perform calculations
result = a + b
# Display the result in the console
print(f'The sum of {a} and {b} is: {result}')
Enter the first number: 12
Enter the second number: 55
The sum of 12 and 55 is: 67
But what if the user enters letters or other characters instead of numbers? When trying to convert such a string to a number, Python will raise an error and stop the program's execution.
int(input('Enter the first number: '))
Enter the first number: abc

ValueError Traceback (most recent call last)
C:\Temp\ipykernel_5404\317567321.py in <module>
> 1 int(input('Enter the first number: '))
ValueError: invalid literal for int() with base 10: 'abc'
You can promptly identify such errors and change the default behavior when they occur, such as prompting the user to enter the number again. However, this is a separate topic for discussion, so for the context of this article, let's assume that the user always enters correct data.
So, we have almost all the components needed to write a complete calculator. Let's expand the functionality of the current version to include all the mathematical operations we planned:
Addition
Subtraction
Division
Multiplication
To improve the readability of the code, let's divide these operations into separate functions. See how it's done with the addition operation.
# Addition
def sum(a, b):
result = a + b
return result
We define a function using the keyword def, provide its name within parentheses, and specify the parameters it takes. Inside the function body, we write what it should do and return the result using the return keyword.
Note that the function body is indented  this is the rule for creating functions. Otherwise, there will be an error.
def test():
print(123)
File "C:\Temp\ipykernel_5404\353670293.py", line 2
print(123)
^
IndentationError: expected an indented block
The result of a function can also be stored in a variable for later use.
x = sum(10, 15)
print(x)
# Output:
25
Similarly, let's create the other calculation functions.
# Subtraction
def subtract(a, b):
result = a  b
return result
# Multiplication
def multiply(a, b):
result = a * b
return result
# Division
def divide(a, b):
result = a / b
return result
The operation functions are ready. Now, let's write a simple Python code that allows the user to choose these operations. We'll use familiar keyboard input and conditional statements. Conditional statements work quite simply. Their names are selfexplanatory.
If the condition is true, for example, 2 == 2,
then execute one block of code;
otherwise,
execute another block of code.
The placeholders for twos can be variables, functions returning values, strings, and even mathematical operations. Let's see how this looks in code with a password check example. Let's assume the correct password is: qwerty.
# Ask the user for a password
password = input('Enter the password: ')
# Check if it matches the intended password
if password == 'qwerty':
print('Correct!')
else:
print('Incorrect password')
Enter the password: abc
Incorrect password
# Ask the user for a password
password = input('Enter the password: ')
# Check if it matches the intended password
if password == 'qwerty':
print('Correct!')
else:
print('Incorrect password')
Enter the password: qwerty
Correct!
Note that code blocks are also indented, just like in functions. The colon is also required.
Now, let's apply the knowledge we've gained to our calculator. We'll ask the user which operation they want to perform and, depending on the input, call the corresponding calculation function. Initially, we'll simply display the selected operation or a message that such an operation does not exist. In the next step, we'll replace the text with the operation call and integrate it with the existing calculator logic.
# Prepare a message for the user about available mathematical operations.# You can store multiline text in triple quotes.
message = '''
Please enter the symbol of the operation you want to perform and press Enter:
+ : Addition
 : Subtraction
/ : Division
* : Multiplication
Your choice:
'''
# Ask the user for the desired action
operation = input(message)
# Display the message about the selected operation or that it doesn't exist
if operation == '+':
print('Addition')
elif operation == '':
print('Subtraction')
elif operation == '/':
print('Division')
elif operation == '*':
print('Multiplication')
else:
print('Unknown operation')
Let's encapsulate all the calculation logic inside a function so that we can conveniently call it within the script.
def calculate(a, b, operation):
result = None
if operation == '+':
result = sum(a, b)
elif operation == '':
result = subtract(a, b)
elif operation == '/':
result = divide(a, b)
elif operation == '*':
result = multiply(a, b)
else:
print('Unknown operation')
return result
Let's also add a function for requesting the operation.
def ask_operation():
message = '''
Please enter the symbol of the operation you want to perform and press Enter:
+ : Addition
 : Subtraction
/ : Division
* : Multiplication
^ or ** : Exponentiation
Your choice:
'''
# Ask the user for the desired action
operation = input(message)
return operation
Now, wrap all the steps of interacting with the calculator in the conditional body of the calculate function
def run_calculator():
# Ask for data
a = int(input('Enter the first number: '))
b = int(input('Enter the second number: '))
# Ask for the operation type
operation = ask_operation()
# Perform calculations
result = calculate(a, b, operation)
# Display the result in the console
print(f'Calculation result: {result}')
Test it out!
run_calculator()
Enter the first number: 15
Enter the second number: 15
Please enter the symbol of the operation you want to perform and press Enter:
+ : Addition
 : Subtraction
/ : Division
* : Multiplication
^ or ** : Exponentiation
Your choice:
*
Calculation result: 225
It works! Congratulations, you've just written your calculator.
Thanks to the fact that the calculation functions are now separate modules (sum, subtract, etc.), we can easily extend the functionality of the calculator.
Let's add the exponentiation operation.
def pow(a, b):
result = a ** b
return result
Add the operation to the calculate function.
def calculate(a, b, operation):
result = None
if operation == '+':
result = sum(a, b)
elif operation == '':
result = subtract(a, b)
elif operation == '/':
result = divide(a, b)
elif operation == '*':
result = multiply(a, b)
# Exponentiation
elif operation == '^' or operation == '**':
result = pow(a, b)
else:
print('Unknown operation')
return result
Let's also provide explanations in the ask_operation
function.
def ask_operation():
message = '''
Please enter the symbol of the operation you want to perform and press Enter:
+ : Addition
 : Subtraction
/ : Division
* : Multiplication
^ or ** : Exponentiation
Your choice:
'''
# Ask the user for the desired action
operation = input(message)
return operation
Check it by running the run_calculator
function.
run_calculator()
Enter the first number: 2
Enter the second number: 8
Please enter the symbol of the operation you want to perform and press Enter:
+ : Addition
 : Subtraction
/ : Division
* : Multiplication
^ or ** : Exponentiation
Your choice: **
Calculation result: 256
Currently, if we enter an unknown operation, the calculator will display a message that such an operation doesn't exist and leave everything as is. Moreover, it will display messages about the obtained result, which should not exist by definition. Let's see:
run_calculator()
Enter the first number: 3
Enter the second number: 5
Please enter the symbol of the operation you want to perform and press Enter:
+ : Addition
 : Subtraction
/ : Division
* : Multiplication
^ or ** : Exponentiation
Your choice: &
Unknown operation
Calculation result: None
Nothing disastrous happened, but there's no benefit either. This process, where we try to input incorrect data into the program and observe how it reacts, is called testing. It's a separate profession, but every professional programmer should be able to perform basic tests.
Let's change the program behavior and allow the user to repeatedly choose the desired operation. To achieve this, we'll place the code with the operation request inside a while loop. The principle of a while loop is similar to conditional statements. It checks a condition for truthfulness and, if it's true, executes a block of code. After execution, the loop repeats  the condition is checked, and the loop's body is executed again. Thus, to exit the loop, we need to change the checked condition to false. Exiting a loop is a crucial moment. If the exit logic is not properly thought out, the loop can continue infinitely, which is not always desirable.
Here's a simple example. We'll print everything the user enters into the console until an empty line is entered.
text = None
while text != '':
text = input('Write something or leave the line empty to finish:\n')
print(f'You entered: {text}\n')
print('Program termination')
Write something or leave the line empty to finish:
123
You entered: 123
Write something or leave the line empty to finish:
test
You entered: test
Write something or leave the line empty to finish:
You entered:
Program termination
Now, let's apply this to the calculator. To do this, we'll modify the ask_operation function.
def ask_operation():
message = '''
Please enter the symbol of the operation you want to perform and press Enter:
+ : Addition
 : Subtraction
/ : Division
* : Multiplication
^ or ** : Exponentiation
Your choice:
'''
# Create a list of available operations
correct_operations = ['+', '', '/', '*', '^', '**']
# Ask the user for the desired action for the first time
operation = input(message)
# Start a loop if the operation is not in the list
while operation not in correct_operations:
print('Such operation is not available. Please try again.')
operation = input(message)
return operation
Calculations will not be performed until a correct operation is entered. The test is successful.
Today, it's easy to find calculators of various types: built into different applications, websites with calculators, standard physical calculators, and diverse engineering modifications, including interesting calculators like Python's ipcalc, which allows subnet IP calculations. But what can be better than something made and customized with your own hands?