Hey there! Welcome to Hostman! 🎉

How to Make a Calculator in Python

23.11.2023
Reading time: 13 min
Hostman Team
Technical writer

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 ready-to-use 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:

Examples of mathematical operation code

Mathematical operations we will use:

2+2 
4

10-5
5

3*3
9

12/4
3.0

Displaying a value

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.

-

Saving the result in a variable

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

Reading strings

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

Concatenating and formatting strings

To make the output more user-friendly, 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!

Converting strings to numbers

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

Handling incorrect data

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.

Creating Functions

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

Conditional Statements

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 self-explanatory.

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 multi-line 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')

Combine Everything

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.

Extending Functionality and Improving Code

Adding Operations

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

Testing and Error Handling

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.

Loops

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.

Conclusion

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?