Как написать свой калькулятор на python

Для создания нашего калькулятора на Python мы будем использовать математические операторы, условные операторы, функции и обработку пользовательского ввода.

В системе должен быть установлен Python 3 на локальном компьютере и на нем должна быть настроена среда программирования.

Ввод от пользователя

Мы будем принимать ввод от пользователя. Для этой цели мы будем использовать функцию Python input(). В этой программе мы позволим пользователю вводить два числа, поэтому давайте запустим программу для запроса двух чисел.

num_1 = input('Enter your first number: ')
num_2 = input('Enter your second number: ')

Вывод:

Enter your first number: 10
Enter your second number: 5

Мы должны сохранить программу перед ее запуском. Вы должны иметь возможность вводить текст в окне терминала в ответ на каждое приглашение.

Определение и использование операторов

Теперь давайте добавим в нашу программу калькулятора такие операторы, как сложение, умножение, деление и вычитание.

num_1 = int(input('Enter your first number: '))
num_2 = int(input('Enter your second number: '))

# Addition
print('{} + {} = '.format(num_1, num_2))
print(num_1 + num_2)

# Subtraction
print('{} - {} = '.format(num_1, num_2))
print(num_1 - num_2)

# Multiplication
print('{} * {} = '.format(num_1, num_2))
print(num_1 * num_2)

# Division
print('{} / {} = '.format(num_1, num_2))
print(num_1 / num_2)
# The format() will help out output look descent and formatted.

Вывод:

Enter your first number: 15
Enter your second number: 10
15 + 10 = 
25
15 - 10 =
05
15 * 10 =
150
15 / 10 =
1.5

Если вы посмотрите на вышеприведенный вывод, мы можем заметить, что как только пользователь вводит num_1 как 15 и num_2 как 10 , все операции калькулятора выполняются.

Если мы хотим ограничить программу выполнением только одной операции за раз, нам придется использовать условные операторы и сделать всю программу операций на основе выбора пользователя.

Итак, мы начнем с добавления некоторой информации в верхней части программы вместе с выбором, который нужно сделать, чтобы пользователь понял, что он должен выбрать.

choice = input('''
Please select the type of operation you want to perform:
+ for addition
- for subtraction
* for multiplication
/ for division
''')

num_1 = int(input('Enter your first number: '))
num_2 = int(input('Enter your second number: '))

if choice == '+':
    print('{} + {} = '.format(num_1, num_2))
    print(num_1 + num_2)

elif choice == '-':
    print('{} - {} = '.format(num_1, num_2))
    print(num_1 - num_2)

elif choice == '*':
    print('{} * {} = '.format(num_1, num_2))
    print(num_1 * num_2)

elif choice == '/':
    print('{} / {} = '.format(num_1, num_2))
    print(num_1 / num_2)

else:
    print('Enter a valid operator, please run the program again.')

Вывод:

Please select the type of operation you want to perform:
+ for addition
- for subtraction
* for multiplication
/ for division

* 

Please enter the first number: 10
Please enter the second number: 40
10 * 40 = 
400

Even though web and mobile applications appear to have taken over the software development market, there’s still demand for traditional graphical user interface (GUI) desktop applications. If you’re interested in building these kinds of applications in Python, then you’ll find a wide variety of libraries to choose from. They include Tkinter, wxPython, PyQt, PySide, and a few others.

In this tutorial, you’ll learn the basics of building GUI desktop applications with Python and PyQt.

In this tutorial, you’ll learn how to:

• Create graphical user interfaces with Python and PyQt
• Connect the user’s events on the app’s GUI with the app’s logic
• Organize a PyQt app using a proper project layout
• Create a fully functional GUI application with PyQt

For this tutorial, you’ll create a calculator app with Python and PyQt. This short project will help you grasp the fundamentals and get you up and running with this GUI library.

You can download the source code for the project and all examples in this tutorial by clicking on the link below:

PS> python -m venv venv
PS> venvScriptsactivate
(venv) PS> python -m pip install pyqt6

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install pyqt6

$ python -m pip install pyqt6

$ sudo apt install python3-pyqt6

# hello.py

"""Simple Hello, World example with PyQt6."""

import sys

# 1. Import QApplication and all the required widgets
from PyQt6.QtWidgets import QApplication, QLabel, QWidget

# hello.py
# ...

# 2. Create an instance of QApplication
app = QApplication([])

# hello.py
# ...

# 3. Create your application's GUI
window = QWidget()
window.setWindowTitle("PyQt App")
window.setGeometry(100, 100, 280, 80)
helloMsg = QLabel("<h1>Hello, World!</h1>", parent=window)
helloMsg.move(60, 15)

# hello.py
# ...

# 4. Show your application's GUI
window.show()

# 5. Run your application's event loop
sys.exit(app.exec())

 1# h_layout.py
 2
 3"""Horizontal layout example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QHBoxLayout,
10    QPushButton,
11    QWidget,
12)
13
14app = QApplication([])
15window = QWidget()
16window.setWindowTitle("QHBoxLayout")
17
18layout = QHBoxLayout()
19layout.addWidget(QPushButton("Left"))
20layout.addWidget(QPushButton("Center"))
21layout.addWidget(QPushButton("Right"))
22window.setLayout(layout)
23
24window.show()
25sys.exit(app.exec())

 1# v_layout.py
 2
 3"""Vertical layout example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QPushButton,
10    QVBoxLayout,
11    QWidget,
12)
13
14app = QApplication([])
15window = QWidget()
16window.setWindowTitle("QVBoxLayout")
17
18layout = QVBoxLayout()
19layout.addWidget(QPushButton("Top"))
20layout.addWidget(QPushButton("Center"))
21layout.addWidget(QPushButton("Bottom"))
22window.setLayout(layout)
23
24window.show()
25sys.exit(app.exec())

 1# g_layout.py
 2
 3"""Grid layout example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QGridLayout,
10    QPushButton,
11    QWidget,
12)
13
14app = QApplication([])
15window = QWidget()
16window.setWindowTitle("QGridLayout")
17
18layout = QGridLayout()
19layout.addWidget(QPushButton("Button (0, 0)"), 0, 0)
20layout.addWidget(QPushButton("Button (0, 1)"), 0, 1)
21layout.addWidget(QPushButton("Button (0, 2)"), 0, 2)
22layout.addWidget(QPushButton("Button (1, 0)"), 1, 0)
23layout.addWidget(QPushButton("Button (1, 1)"), 1, 1)
24layout.addWidget(QPushButton("Button (1, 2)"), 1, 2)
25layout.addWidget(QPushButton("Button (2, 0)"), 2, 0)
26layout.addWidget(
27    QPushButton("Button (2, 1) + 2 Columns Span"), 2, 1, 1, 2
28)
29window.setLayout(layout)
30
31window.show()
32sys.exit(app.exec())

 1# f_layout.py
 2
 3"""Form layout example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QFormLayout,
10    QLineEdit,
11    QWidget,
12)
13
14app = QApplication([])
15window = QWidget()
16window.setWindowTitle("QFormLayout")
17
18layout = QFormLayout()
19layout.addRow("Name:", QLineEdit())
20layout.addRow("Age:", QLineEdit())
21layout.addRow("Job:", QLineEdit())
22layout.addRow("Hobbies:", QLineEdit())
23window.setLayout(layout)
24
25window.show()
26sys.exit(app.exec())

 1# dialog.py
 2
 3"""Dialog-style application."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QDialog,
10    QDialogButtonBox,
11    QFormLayout,
12    QLineEdit,
13    QVBoxLayout,
14)
15
16class Window(QDialog):
17    def __init__(self):
18        super().__init__(parent=None)
19        self.setWindowTitle("QDialog")
20        dialogLayout = QVBoxLayout()
21        formLayout = QFormLayout()
22        formLayout.addRow("Name:", QLineEdit())
23        formLayout.addRow("Age:", QLineEdit())
24        formLayout.addRow("Job:", QLineEdit())
25        formLayout.addRow("Hobbies:", QLineEdit())
26        dialogLayout.addLayout(formLayout)
27        buttons = QDialogButtonBox()
28        buttons.setStandardButtons(
29            QDialogButtonBox.StandardButton.Cancel
30            | QDialogButtonBox.StandardButton.Ok
31        )
32        dialogLayout.addWidget(buttons)
33        self.setLayout(dialogLayout)
34
35if __name__ == "__main__":
36    app = QApplication([])
37    window = Window()
38    window.show()
39    sys.exit(app.exec())

 1# main_window.py
 2
 3"""Main window-style application."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QLabel,
10    QMainWindow,
11    QStatusBar,
12    QToolBar,
13)
14
15class Window(QMainWindow):
16    def __init__(self):
17        super().__init__(parent=None)
18        self.setWindowTitle("QMainWindow")
19        self.setCentralWidget(QLabel("I'm the Central Widget"))
20        self._createMenu()
21        self._createToolBar()
22        self._createStatusBar()
23
24    def _createMenu(self):
25        menu = self.menuBar().addMenu("&Menu")
26        menu.addAction("&Exit", self.close)
27
28    def _createToolBar(self):
29        tools = QToolBar()
30        tools.addAction("Exit", self.close)
31        self.addToolBar(tools)
32
33    def _createStatusBar(self):
34        status = QStatusBar()
35        status.showMessage("I'm the Status Bar")
36        self.setStatusBar(status)
37
38if __name__ == "__main__":
39    app = QApplication([])
40    window = Window()
41    window.show()
42    sys.exit(app.exec())

widget.signal.connect(slot_function)

 1# signals_slots.py
 2
 3"""Signals and slots example."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import (
 8    QApplication,
 9    QLabel,
10    QPushButton,
11    QVBoxLayout,
12    QWidget,
13)
14
15def greet():
16    if msgLabel.text():
17        msgLabel.setText("")
18    else:
19        msgLabel.setText("Hello, World!")
20
21app = QApplication([])
22window = QWidget()
23window.setWindowTitle("Signals and slots")
24layout = QVBoxLayout()
25
26button = QPushButton("Greet")
27button.clicked.connect(greet)
28
29layout.addWidget(button)
30msgLabel = QLabel("")
31layout.addWidget(msgLabel)
32window.setLayout(layout)
33window.show()
34sys.exit(app.exec())

# signals_slots.py
# ...

def greet(name):
    if msg.text():
        msg.setText("")
    else:
        msg.setText(f"Hello, {name}")

# ...

# signals_slots.py

"""Signals and slots example."""

import sys
from functools import partial

# ...

button = QPushButton("Greet")
button.clicked.connect(partial(greet, "World!"))

# ...

 1# pycalc.py
 2
 3"""PyCalc is a simple calculator built with Python and PyQt."""
 4
 5import sys
 6
 7from PyQt6.QtWidgets import QApplication, QMainWindow, QWidget
 8
 9WINDOW_SIZE = 235
10
11class PyCalcWindow(QMainWindow):
12    """PyCalc's main window (GUI or view)."""
13
14    def __init__(self):
15        super().__init__()
16        self.setWindowTitle("PyCalc")
17        self.setFixedSize(WINDOW_SIZE, WINDOW_SIZE)
18        centralWidget = QWidget(self)
19        self.setCentralWidget(centralWidget)
20
21def main():
22    """PyCalc's main function."""
23    pycalcApp = QApplication([])
24    pycalcWindow = PyCalcWindow()
25    pycalcWindow.show()
26    sys.exit(pycalcApp.exec())
27
28if __name__ == "__main__":
29    main()

# pycalc.py

import sys

from PyQt6.QtCore import Qt
from PyQt6.QtWidgets import (
    QApplication,
    QGridLayout,
    QLineEdit,
    QMainWindow,
    QPushButton,
    QVBoxLayout,
    QWidget,
)

# ...

# pycalc.py
# ...

class PyCalcWindow(QMainWindow):
    """PyCalc's main window (GUI or view)."""

    def __init__(self):
        super().__init__()
        self.setWindowTitle("PyCalc")
        self.setFixedSize(WINDOW_SIZE, WINDOW_SIZE)
        self.generalLayout = QVBoxLayout()
        centralWidget = QWidget(self)
        centralWidget.setLayout(self.generalLayout)
        self.setCentralWidget(centralWidget)
        self._createDisplay()
        self._createButtons()

# ...

# pycalc.py
# ...

WINDOW_SIZE = 235
DISPLAY_HEIGHT = 35

class PyCalcWindow(QMainWindow):
    # ...

    def _createDisplay(self):
        self.display = QLineEdit()
        self.display.setFixedHeight(DISPLAY_HEIGHT)
        self.display.setAlignment(Qt.AlignmentFlag.AlignRight)
        self.display.setReadOnly(True)
        self.generalLayout.addWidget(self.display)

# ...

# pycalc.py
# ...

WINDOW_SIZE = 235
DISPLAY_HEIGHT = 35
BUTTON_SIZE = 40

# ...

# pycalc.py
# ...

class PyCalcWindow(QMainWindow):
    # ...

    def _createButtons(self):
        self.buttonMap = {}
        buttonsLayout = QGridLayout()
        keyBoard = [
            ["7", "8", "9", "/", "C"],
            ["4", "5", "6", "*", "("],
            ["1", "2", "3", "-", ")"],
            ["0", "00", ".", "+", "="],
        ]

        for row, keys in enumerate(keyBoard):
            for col, key in enumerate(keys):
                self.buttonMap[key] = QPushButton(key)
                self.buttonMap[key].setFixedSize(BUTTON_SIZE, BUTTON_SIZE)
                buttonsLayout.addWidget(self.buttonMap[key], row, col)

        self.generalLayout.addLayout(buttonsLayout)

# ...

# pycalc.py
# ...

class PyCalcWindow(QMainWindow):
    # ...

    def setDisplayText(self, text):
        """Set the display's text."""
        self.display.setText(text)
        self.display.setFocus()

    def displayText(self):
        """Get the display's text."""
        return self.display.text()

    def clearDisplay(self):
        """Clear the display."""
        self.setDisplayText("")

# ...

# pycalc.py
# ...

ERROR_MSG = "ERROR"
WINDOW_SIZE = 235
# ...

# pycalc.py
# ...

class PyCalcWindow(QMainWindow):
    # ...

def evaluateExpression(expression):
    """Evaluate an expression (Model)."""
    try:
        result = str(eval(expression, {}, {}))
    except Exception:
        result = ERROR_MSG
    return result

# ...

# pytcalc.py

import sys
from functools import partial
# ...

def evaluateExpression(expression):
    # ...

class PyCalc:
    """PyCalc's controller class."""

    def __init__(self, model, view):
        self._evaluate = model
        self._view = view
        self._connectSignalsAndSlots()

    def _calculateResult(self):
        result = self._evaluate(expression=self._view.displayText())
        self._view.setDisplayText(result)

    def _buildExpression(self, subExpression):
        if self._view.displayText() == ERROR_MSG:
            self._view.clearDisplay()
        expression = self._view.displayText() + subExpression
        self._view.setDisplayText(expression)

    def _connectSignalsAndSlots(self):
        for keySymbol, button in self._view.buttonMap.items():
            if keySymbol not in {"=", "C"}:
                button.clicked.connect(
                    partial(self._buildExpression, keySymbol)
                )
        self._view.buttonMap["="].clicked.connect(self._calculateResult)
        self._view.display.returnPressed.connect(self._calculateResult)
        self._view.buttonMap["C"].clicked.connect(self._view.clearDisplay)

# ...

# pytcalc.py
# ...

def main():
    """PyCalc's main function."""
    pycalcApp = QApplication([])
    pycalcWindow = PyCalcWindow()
    pycalcWindow.show()
    PyCalc(model=evaluateExpression, view=pycalcWindow)
    sys.exit(pycalcApp.exec())

In this Python tutorial, we will make a calculator in python, which can add, subtract, divide, and multiply depending upon the user-entered input.

Also, we will discuss how to create a Python Calculator using Tkinter.

Let us see how we can create a calculator in python using functions.

As you can see that we have created a simple calculator in python, which can perform different arithmetical operations like add, subtract, multiply, and divide. The user-defined function is add(), subtract(), multiply() and divide() will evaluate respective operation and display the output.

Example:

def add(x,y):
    return x + y
def subtract(x,y):
    return x - y
def multiply(x,y):
    return x * y
def divide(x,y):
    return x / y
print("Select operation.")
print("1.Add")
print("2.Subtract")
print("3.Multiply")
print("4.Divide")
while True:
    choice = input("Enter your choice(1/2/3/4): ")
    if choice in ('1', '2', '3', '4'):
        number1 = float(input("Enter first number: "))
        number2 = float(input("Enter second number: "))
        if choice == '1':
           print(number1, "+", number2, "=", add(number1, number2))
        elif choice == '2':
           print(number1, "-", number2, "=", subtract(number1, number2))
        elif choice == '3':
           print(number1, "*", number2, "=", multiply(number1, number2))
        elif choice == '4':
           print(number1, "/", number2, "=", divide(number1, number2))
        break
     else:
         print("Entered input is invalid")

You can refer to the below screenshot to make a calculator in Python.

Output:
Here, we ask the user to choose an operation of their choice. If the option is 1,2,3, and 4 then it will be valid else it will display “Invalid input”. If the option is valid then we have to enter the two numbers and according to the user entered choice, it will perform the operation.

You may also like Python Tkinter Stopwatch and How to Take User Input and Store in Variable using Python Tkinter.

Calculator in python using class

Let’s see step by step how we can create a class which will perform basic calculator operation.

• To make a calculator using class. Classes are required to create an object. Classes make the code more efficient and simple enough to understand.
• First, we will create a class calculator and all the function is defined like addition, subtraction, multiplication, and division.
• Self is used while calling the function using obj1.function(). Here, the function will call itself.
• Now, we will take the input from the user and the object is created.
• And at last, create the user choice to perform the operation they need and print the value in the output.

Example:

class calculator:
    def addition(self):
        print(x + y)
    def subtraction(self):
        print(x - y)
    def multiplication(self):
        print(x * y)
    def division(self):
        print(x / y)
x = int(input("Enter first number:"))
y = int(input("Enter second number:"))
obj1 = calculator()
choice = 1
while choice !=0:
    print("1. ADDITION")
    print("2. SUBTRACTION")
    print("3. MULTIPLICATION")
    print("4. DIVISION")
    choice = int(input("Enter your choice:"))
    if choice == 1:
        print(obj1.addition())
    elif choice == 2:
        print(obj1.subtraction())
    elif choice == 3:
        print(obj1.multiplication())
    elif choice == 4:
        print(obj1.division())
    else:
        print("Invalid choice")

Now, you can see code with the output.

Output:

You may like, How to Set Background to be an Image in Python Tkinter

Calculator in python without function

We have created a simple calculator in python without a function that can perform different arithmetical operations like add, subtract, multiply, and divide.

Example:

first_val = input("Enter 1st number: ")
first_val = int(first_val)
cal = input("Enter operator: ")
second_val = input("Enter 2nd number: ")
second_val = int(second_val)
if cal == "+":
    print(first_val + second_val)
elif cal == "-":
    print(first_val - second_val)
elif cal == "*":
    print(first_val * second_val)
elif cal == "/":
    print(first_val / second_val)

Below screenshot shows how we can create a calculator without function.

You may also like, How to display data in textboxes using Python Tkinter?

Calculator in python code

In this, we will see the code for a calculator in python. Here, we create an individual function to perform the operation like add, subtract, multiply, and divide. It will accept the user’s input along with the choice of operator and return the result.

Example:

def add(x, y):
   return x + y
def subtract(x, y):
   return x - y
def multiply(x, y):
   return x * y
def divide(x, y):
   return x / y
print("select an operation")
print("+")
print("-")
print("*")
print("/")
choice = input("Enter any operator to use")
a = int(input("Enter first number: "))
b = int(input("Enter second number: "))
if choice == '+':
   print(a,"+",b,"=", add(a,b))
elif choice == '-':
   print(a,"-",b,"=", subtract(a,b))
elif choice == '*':
   print(a,"*",b,"=", multiply(a,b))
elif choice == '/':
   print(a,"/",b,"=", divide(a,b))
else:
   print("Invalid input")

You can see the below screenshot for calculator in python code and the output.

Output:

This is how we can make a calculator in Python.

Read: Python Tkinter Mainloop

Python Tkinter Calculator

Let us see how to create a simple calculator using Python Tkinter. I hope this Python Tkinter calculator example will help you to create a simple calculator in Python.

If you are new to Python GUI programming or Python Tkinter, check out Python GUI Programming (Python Tkinter)

Create a Simple Calculator using Python Tkinter

• Python Tkinter is used for various GUI applications, one of them is calculator.
• Working with calculator app will help you in understanding python better.
• In this section we will provide you entire source code with explanation.
• Please advised to read the entire blog & leave a comment to clarify any doubt.

Planning for Python Tkinter Calculator

In this section, we will discuss the secret of training yourself before writing a code for the python Tkinter calculator. We will discuss the look of an application, functions it is going to perform, and source of inspiration.

• The source of inspiration is the calculator on the Windows 10 operating system.
• It has a grey background in the display & black background on the buttons.
• The text color of the entire application is white.
• The application always opens at the bottom right side.
• Numbers are displayed on the right side of the screen.

After observing the entire windows 10 calculator application, now it’s time to write things we are going to use or implement in our application.

1. Every time application will open on the bottom right side.
2. the application will have a grey background in the display & black background in the buttons.
3. The text color of the entire application will be white
4. a window will have a fixed size & can’t be resized.
5. The calculator will have the basic functionality of addition, subtraction, multiplication & division.
6. Numbers will be displayed on the right side of the screen.

Algorithm to Create Python Tkinter Calculator

In this section, we will discuss the algorithm for creating a python Tkinter calculator. Also, we will provide the data-flow diagram (DFD) for the same.

ws = Tk()
ws.title('Calculator')
ws.geometry('250x400+500+100')
ws.resizable(0,0)

• the first line of the code is used to initialize the parent layer.
• the second line is used to set the title of the window. The title is the name on the top of the window next to the feather.
• the third line is set the width, height & position of the window.
  • width = 250
  • height = 400
  • position x = 500
  • position y = 100
• Resizable determines the amount of screen that can be stretched. The screen can be stretched on the x & y-axis. Since we have provided both the values as 0. That means the screen can’t be stretched either way.

frame_1 = Frame(ws)
frame_1.pack(expand=True, fill=BOTH)

• To place widgets like labels & buttons we have to create 4 frames.
• Each frame is allowed to fully expand in the x and y direction if space is available.
• In this way all the frames will have similar space & buttons placed in them will have symmetry.
  • expand=True : This allows for expansion in the available space.
  • fill=both : direction for espansion

key_1 = Button(
frame_1,
text='1',
font=('Arial', 22),
border = 0,
relief = GROOVE,
bg = '#2E2E2B',
fg = 'white',
command = lambda: display(1)
)

In this code, we are creating a button. To understand the button please refer to our button section. Here, under the command, we can call a function but we cannot pass an argument to a function. That is why we have used the anonymous function lambda here. To know more about the anonymous function please refer to our section on the anonymous function.

Here is the DFD of calculator

Global Variables

num = ''

• Variables used in a function are limited to that function only
• if we want to use a particular variable in other function
• then we have to declare that variable as a global variable.
• In this code, we have declared num as a global variable.
• any function referring to this variable must use the global keyword before the variable name
• Changes made by any function on this variables will be observed by other functions too.
• for example, if any function sets the value of the num to ’10’ then other functions using num will also have num value as ’10’.

Explaining function:

equal_btn()

def equal_btn():
     global num
     add=str(eval(num))
     scr_lbl['text'] = add
     num=''

• equal_btn() function is used multiple times with the slight change in variable name in line 3 & line 4.
• here, built-in function eval() plays an important role.
• eval() takes a string as input and converts it into an integer & performs the operation.
• that means if the string ‘2+3’ is passed to eval it will return 5 as output

def clear_scr(number)

def clear_scr():
    global num
    num = ''
    scr_lbl['text'] = num

• this function is called when C is clicked by user.
• it clears everything on the display and sets the value of num to empty string.

def display(number)

def display(number):
    global num 
    num = num + str(number)
    scr_lbl['text'] = num

• this function is responsible for displaying numbers on the screen.
• every time user clicks on the numbered button, it concat with the existing string.
• so when clicking on 1 it displays 1 on the screen. then when we click on 2 it displays 12 and so on.

Code:

from tkinter import *

ws = Tk()
ws.title('Calculator')
ws.geometry('250x400+500+100')
ws.resizable(0,0)

# global variables
num = ''

# functions
def display(number):
    global num 
    num = num + str(number)
    scr_lbl['text'] = num
    

def clear_scr():
    global num
    num = ''
    scr_lbl['text'] = num


def equal_btn():
     global num
     add=str(eval(num))
     scr_lbl['text'] = add
     num=''
def equal_btn():
     global num
     sub=str(eval(num))
     scr_lbl['text'] = sub
     num=''     
def equal_btn():
     global num
     mul=str(eval(num))
     scr_lbl['text'] = mul
     num=''
def equal_btn():
     global num
     div=str(eval(num))
     scr_lbl['text'] = div
     num=''    

var = StringVar()

# frames 
frame_1 = Frame(ws) 
frame_1.pack(expand=True, fill=BOTH)

frame_2 = Frame(ws)
frame_2.pack(expand=True, fill=BOTH)

frame_3 = Frame(ws)
frame_3.pack(expand=True, fill=BOTH)

frame_4 = Frame(ws)
frame_4.pack(expand=True, fill=BOTH)

# label
scr_lbl = Label(
    frame_1,
    textvariable='',
    font=('Arial', 20),
    anchor = SE,
    bg = '#595954',
    fg = 'white' 
    )

scr_lbl.pack(expand=True, fill=BOTH)

# buttons
key_1 = Button(
    frame_1,
    text='1',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(1)
    )

key_1.pack(expand=True, fill=BOTH, side=LEFT)

key_2 = Button(
    frame_1,
    text='2',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(2)
    )

key_2.pack(expand=True, fill=BOTH, side=LEFT)

key_3 = Button(
    frame_1,
    text='3',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(3)
    )

key_3.pack(expand=True, fill=BOTH, side=LEFT)

key_add = Button(
    frame_1,
    text='+',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display('+')
    )

key_add.pack(expand=True, fill=BOTH, side=LEFT)

key_4 = Button(
    frame_2,
    text='4',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(4)
    )

key_4.pack(expand=True, fill=BOTH, side=LEFT)

key_5 = Button(
    frame_2,
    text='5',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(5)
    )

key_5.pack(expand=True, fill=BOTH, side=LEFT)

key_6 = Button(
    frame_2,
    text='6',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(6)
    )

key_6.pack(expand=True, fill=BOTH, side=LEFT)

key_sub = Button(
    frame_2,
    text='-',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display('-')
    )

key_sub.pack(expand=True, fill=BOTH, side=LEFT)

key_7 = Button(
    frame_3,
    text='7',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(7)
    )

key_7.pack(expand=True, fill=BOTH, side=LEFT)

key_8 = Button(
    frame_3,
    text='8',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(8)
    )

key_8.pack(expand=True, fill=BOTH, side=LEFT)

key_9 = Button(
    frame_3,
    text='9',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(9)
    )

key_9.pack(expand=True, fill=BOTH, side=LEFT)

key_mul = Button(
    frame_3,
    text='*',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display('*')
    )

key_mul.pack(expand=True, fill=BOTH, side=LEFT)


key_clr = Button(
    frame_4,
    text='C',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = clear_scr 
    )

key_clr.pack(expand=True, fill=BOTH, side=LEFT)

key_0 = Button(
    frame_4,
    text='0',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display(0)
    )

key_0.pack(expand=True, fill=BOTH, side=LEFT)

key_res = Button(
    frame_4,
    text='=',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = equal_btn
    )

key_res.pack(expand=True, fill=BOTH, side=LEFT)

key_div = Button(
    frame_4,
    text='/',
    font=('Arial', 22),
    border = 0,
    relief = GROOVE,
    bg = '#2E2E2B',
    fg = 'white',
    command = lambda: display('/')
    )

key_div.pack(expand=True, fill=BOTH, side=LEFT)

ws.mainloop()

Output:

So in this tutorial we have learned about how to create calculator using python tkinter.

You may like the following Python tutorials:

• Regular Expressions in Python
• Python Booleans
• Python print 2 decimal places
• Python generators (Python Generator vs Iterator)
• Python Recursion
• Python sort list of tuples
• Python invalid literal for int() with base 10
• Remove Unicode characters in python
• Comment lines in Python
• How to make a matrix in Python
• Python Tkinter Progress bar
• Python Tkinter Exit Program

In this Python tutorial, we have learned how to make a calculator in Python. Also, we have covered these below topics:

• Calculator in python using class
• Calculator in python without function
• Calculator in python code
• Python Tkinter calculator

Hey python developers, in Python Calculator tutorial you will learn to create a simple GUI calculator. In this post i will show you how to develop a simple calculator using tkinter module in python. So let’s move further to create a simple python calculator.

Python offers a lot of options to develop  GUI applications, but Tkinter is the most usable module for developing GUI(Graphical User Interface). Since Tkinter is cross-platform so it works on both windows and Linux. So here i am using Tkinter module to create a simple python calculator.

Python Calculator Tutorial – Getting Started With Tkinter

The fastest and easiest way of developing GUI applications in python is working with Tkinter. So let’s took a quick look on Tkinter.

What is Tkinter

• The Tkinter module (“Tk interface”) is the standard Python interface to the Tk GUI toolkit.
• Both Tk and Tkinter are available on most Unix platforms, as well as on Windows systems.
• If you work on Linux/Ubuntu then you have to install Tkinter module on your machine for running programs, but on windows you don’t need to install it because it comes with the default python installation.

Prerequisite For Python Calculator

For developing a simple GUI calculator in python you must have to prior knowledge of following –

• Tkinter
• Lambda

Look Of A Simple GUI Python Calculator

Look at this calculator. Yup this is looking very cool. So now we have to create this calculator in python.

On this calculator we can perform following simple mathematical calculations –

• Multiplication
• Addition
• Subtraction
• Division

And now we will start writing codes for making this. To create this we have to do four things –

• Importing Tkinter module
• Creating the main interface(window for calculator)
• Adding any number of widgets to the main interface
• Applying the event trigger on widgets

Creating Window For Calculator

First of all we will create a window of calculator. So write the following code.

Let’s see the output.

We have created this frame successfully, now lets move on ahead.

Adding Display Widget

For creating display widget write the following code inside the class app.

So now the output is –

Adding Clear Button Widget

Now we will create a clear button. Whenever this button will be pressed all the stuffs from display will be erased. So write the following code for this.

And now you can see the output.

Adding Numbers And Symbols Widget

To add numbers and symbols inside the frame, you have to write the following code.

And now you can see the output. It’s looking cool.

Adding Equal Button

For implementing Equal button write the following code.

So now our calculator looks like as below.

Applying Event Trigger On Widgets

Now the last thing but very important is to apply event triggers on widgets. It means whenever you click any widget some function will be performed. So write the following code

Complete Code For Python Calculator

So now i am collecting and keeping  all the above codes in one place. So our entire code for making a simple calculator in python is below.

So now its time to see the calculator and you can perform any operation on it. So let’s start your calculation.

Congratulations, We have created python calculator successfully, that’s pretty cool, and i hope you have really enjoyed while making this. So surely comment your feelings about this.

Recommended Articles

• Python Simple HTTP Server : A Simple HTTP Web Server With Python
• Python Chatbot – Build Your Own Chatbot With Python
• Python Rest API Example using Bottle Framework
• PyGame Sprite Animation Tutorial – Simple Walk Loop
• Django Forms Example – Generating Forms with Django Form Class
• Speech Recognition Python – Converting Speech to Text

So Guys this was all about the Python Calculator Tutorial. I hope, you liked it and if it is helpful for you then please share it with others and help them in learning python. And if you have any question regarding this post then leave your queries in comment section. In upcoming posts i will come with some interesting python applications, and if you want to learn making any particular application then suggest me your idea, i will try to fulfill your need. Thanks All of you.

from tkinter import *

import math

import tkinter.messagebox

root = Tk()

root.title("Scientific Calculator")

root.configure(background = 'white')

root.resizable(width=False, height=False)

root.geometry("480x568+450+90")

calc = Frame(root)

calc.grid()

class Calc():

    def __init__(self):

        self.total=0

        self.current=''

        self.input_value=True

        self.check_sum=False

        self.op=''

        self.result=False

    def numberEnter(self, num):

        self.result=False

        firstnum=txtDisplay.get()

        secondnum=str(num)

        if self.input_value:

            self.current = secondnum

            self.input_value=False

        else:

            if secondnum == '.':

                if secondnum in firstnum:

                    return

            self.current = firstnum+secondnum

        self.display(self.current)

    def sum_of_total(self):

        self.result=True

        self.current=float(self.current)

        if self.check_sum==True:

            self.valid_function()

        else:

            self.total=float(txtDisplay.get())

    def display(self, value):

        txtDisplay.delete(0, END)

        txtDisplay.insert(0, value)

    def valid_function(self):

        if self.op == "add":

            self.total += self.current

        if self.op == "sub":

            self.total -= self.current

        if self.op == "multi":

            self.total *= self.current

        if self.op == "divide":

            self.total /= self.current

        if self.op == "mod":

            self.total %= self.current

        self.input_value=True

        self.check_sum=False

        self.display(self.total)

    def operation(self, op):

        self.current = float(self.current)

        if self.check_sum:

            self.valid_function()

        elif not self.result:

            self.total=self.current

            self.input_value=True

        self.check_sum=True

        self.op=op

        self.result=False

    def Clear_Entry(self):

        self.result = False

        self.current = "0"

        self.display(0)

        self.input_value=True

    def All_Clear_Entry(self):

        self.Clear_Entry()

        self.total=0

    def pi(self):

        self.result =  False

        self.current = math.pi

        self.display(self.current)

    def tau(self):

        self.result =  False

        self.current = math.tau

        self.display(self.current)

    def e(self):

        self.result =  False

        self.current = math.e

        self.display(self.current)

    def mathPM(self):

        self.result = False

        self.current = -(float(txtDisplay.get()))

        self.display(self.current)

    def squared(self):

        self.result = False

        self.current = math.sqrt(float(txtDisplay.get()))

        self.display(self.current)

    def cos(self):

        self.result = False

        self.current = math.cos(math.radians(float(txtDisplay.get())))

        self.display(self.current)

    def cosh(self):

        self.result = False

        self.current = math.cosh(math.radians(float(txtDisplay.get())))

        self.display(self.current)

    def tan(self):

        self.result = False

        self.current = math.tan(math.radians(float(txtDisplay.get())))

        self.display(self.current)

    def tanh(self):

        self.result = False

        self.current = math.tanh(math.radians(float(txtDisplay.get())))

        self.display(self.current)

    def sin(self):

        self.result = False

        self.current = math.sin(math.radians(float(txtDisplay.get())))

        self.display(self.current)

    def sinh(self):

        self.result = False

        self.current = math.sinh(math.radians(float(txtDisplay.get())))

        self.display(self.current)

    def log(self):

        self.result = False

        self.current = math.log(float(txtDisplay.get()))

        self.display(self.current)

    def exp(self):

        self.result = False

        self.current = math.exp(float(txtDisplay.get()))

        self.display(self.current)

    def acosh(self):

        self.result = False

        self.current = math.acosh(float(txtDisplay.get()))

        self.display(self.current)

    def asinh(self):

        self.result = False

        self.current = math.asinh(float(txtDisplay.get()))

        self.display(self.current)

    def expm1(self):

        self.result = False

        self.current = math.expm1(float(txtDisplay.get()))

        self.display(self.current)

    def lgamma(self):

        self.result = False

        self.current = math.lgamma(float(txtDisplay.get()))

        self.display(self.current)

    def degrees(self):

        self.result = False

        self.current = math.degrees(float(txtDisplay.get()))

        self.display(self.current)

    def log2(self):

        self.result = False

        self.current = math.log2(float(txtDisplay.get()))

        self.display(self.current)

    def log10(self):

        self.result = False

        self.current = math.log10(float(txtDisplay.get()))

        self.display(self.current)

    def log1p(self):

        self.result = False

        self.current = math.log1p(float(txtDisplay.get()))

        self.display(self.current)

added_value = Calc()

txtDisplay = Entry(calc, font=('Helvetica',20,'bold'),

                   bg='black',fg='white',

                   bd=30,width=28,justify=RIGHT)

txtDisplay.grid(row=0,column=0, columnspan=4, pady=1)

txtDisplay.insert(0,"0")

numberpad = "789456123"

i=0

btn = []

for j in range(2,5):

    for k in range(3):

        btn.append(Button(calc, width=6, height=2,

                          bg='black',fg='white',

                          font=('Helvetica',20,'bold'),

                          bd=4,text=numberpad[i]))

        btn[i].grid(row=j, column= k, pady = 1)

        btn[i]["command"]=lambda x=numberpad[i]:added_value.numberEnter(x)

        i+=1

btnClear = Button(calc, text=chr(67),width=6,

                  height=2,bg='powder blue',

                  font=('Helvetica',20,'bold')

                  ,bd=4, command=added_value.Clear_Entry

                 ).grid(row=1, column= 0, pady = 1)

btnAllClear = Button(calc, text=chr(67)+chr(69),

                     width=6, height=2,

                     bg='powder blue',

                     font=('Helvetica',20,'bold'),

                     bd=4,

                     command=added_value.All_Clear_Entry

                    ).grid(row=1, column= 1, pady = 1)

btnsq = Button(calc, text="u221A",width=6, height=2,

               bg='powder blue', font=('Helvetica',

                                       20,'bold'),

               bd=4,command=added_value.squared

              ).grid(row=1, column= 2, pady = 1)

btnAdd = Button(calc, text="+",width=6, height=2,

                bg='powder blue',

                font=('Helvetica',20,'bold'),

                bd=4,command=lambda:added_value.operation("add")

                ).grid(row=1, column= 3, pady = 1)

btnSub = Button(calc, text="-",width=6,

                height=2,bg='powder blue',

                font=('Helvetica',20,'bold'),

                bd=4,command=lambda:added_value.operation("sub")

                ).grid(row=2, column= 3, pady = 1)

btnMul = Button(calc, text="x",width=6,

                height=2,bg='powder blue',

                font=('Helvetica',20,'bold'),

                bd=4,command=lambda:added_value.operation("multi")

                ).grid(row=3, column= 3, pady = 1)

btnDiv = Button(calc, text="/",width=6,

                height=2,bg='powder blue',

                font=('Helvetica',20,'bold'),

                bd=4,command=lambda:added_value.operation("divide")

                ).grid(row=4, column= 3, pady = 1)

btnZero = Button(calc, text="0",width=6,

                 height=2,bg='black',fg='white',

                 font=('Helvetica',20,'bold'),

                 bd=4,command=lambda:added_value.numberEnter(0)

                 ).grid(row=5, column= 0, pady = 1)

btnDot = Button(calc, text=".",width=6,

                height=2,bg='powder blue',

                font=('Helvetica',20,'bold'),

                bd=4,command=lambda:added_value.numberEnter(".")

                ).grid(row=5, column= 1, pady = 1)

btnPM = Button(calc, text=chr(177),width=6,

               height=2,bg='powder blue', font=('Helvetica',20,'bold'),

               bd=4,command=added_value.mathPM

              ).grid(row=5, column= 2, pady = 1)

btnEquals = Button(calc, text="=",width=6,

                   height=2,bg='powder blue',

                   font=('Helvetica',20,'bold'),

                   bd=4,command=added_value.sum_of_total

                  ).grid(row=5, column= 3, pady = 1)

btnPi = Button(calc, text="pi",width=6,

               height=2,bg='black',fg='white',

               font=('Helvetica',20,'bold'),

               bd=4,command=added_value.pi

              ).grid(row=1, column= 4, pady = 1)

btnCos = Button(calc, text="Cos",width=6,

                height=2,bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=added_value.cos

               ).grid(row=1, column= 5, pady = 1)

btntan = Button(calc, text="tan",width=6,

                height=2,bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=added_value.tan

               ).grid(row=1, column= 6, pady = 1)

btnsin = Button(calc, text="sin",width=6,

                height=2,bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=added_value.sin

               ).grid(row=1, column= 7, pady = 1)

btn2Pi = Button(calc, text="2pi",width=6,

                height=2,bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=added_value.tau

               ).grid(row=2, column= 4, pady = 1)

btnCosh = Button(calc, text="Cosh",width=6,

                 height=2,bg='black',fg='white',

                 font=('Helvetica',20,'bold'),

                 bd=4,command=added_value.cosh

                ).grid(row=2, column= 5, pady = 1)

btntanh = Button(calc, text="tanh",width=6,

                 height=2,bg='black',fg='white',

                 font=('Helvetica',20,'bold'),

                 bd=4,command=added_value.tanh

                ).grid(row=2, column= 6, pady = 1)

btnsinh = Button(calc, text="sinh",width=6,

                 height=2,bg='black',fg='white',

                 font=('Helvetica',20,'bold'),

                 bd=4,command=added_value.sinh

                ).grid(row=2, column= 7, pady = 1)

btnlog = Button(calc, text="log",width=6,

                height=2,bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=added_value.log

               ).grid(row=3, column= 4, pady = 1)

btnExp = Button(calc, text="exp",width=6, height=2,

                bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=added_value.exp

               ).grid(row=3, column= 5, pady = 1)

btnMod = Button(calc, text="Mod",width=6,

                height=2,bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=lambda:added_value.operation("mod")

                ).grid(row=3, column= 6, pady = 1)

btnE   = Button(calc, text="e",width=6,

                height=2,bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=added_value.e

               ).grid(row=3, column= 7, pady = 1)

btnlog10 = Button(calc, text="log10",width=6,

                  height=2,bg='black',fg='white',

                  font=('Helvetica',20,'bold'),

                  bd=4,command=added_value.log10

                 ).grid(row=4, column= 4, pady = 1)

btncos   = Button(calc, text="log1p",width=6,

                  height=2,bg='black',fg='white',

                  font=('Helvetica',20,'bold'),

                  bd=4,command=added_value.log1p

                 ).grid(row=4, column= 5, pady = 1)

btnexpm1 = Button(calc, text="expm1",width=6,

                  height=2,bg='black',fg='white',

                  font=('Helvetica',20,'bold'),

                  bd = 4,command=added_value.expm1

                 ).grid(row=4, column= 6, pady = 1)

btngamma = Button(calc, text="gamma",width=6,

                  height=2,bg='black',fg='white',

                  font=('Helvetica',20,'bold'),

                  bd=4,command=added_value.lgamma

                 ).grid(row=4, column= 7, pady = 1)

btnlog2 = Button(calc, text="log2",width=6,

                 height=2,bg='black',fg='white',

                 font=('Helvetica',20,'bold'),

                 bd=4,command=added_value.log2

                ).grid(row=5, column= 4, pady = 1)

btndeg = Button(calc, text="deg",width=6,

                height=2,bg='black',fg='white',

                font=('Helvetica',20,'bold'),

                bd=4,command=added_value.degrees

               ).grid(row=5, column= 5, pady = 1)

btnacosh = Button(calc, text="acosh",width=6,

                  height=2,bg='black',fg='white',

                  font=('Helvetica',20,'bold'),

                  bd=4,command=added_value.acosh

                 ).grid(row=5, column= 6, pady = 1)

btnasinh = Button(calc, text="asinh",width=6,

                  height=2,bg='black',fg='white',

                  font=('Helvetica',20,'bold'),

                  bd=4,command=added_value.asinh

                 ).grid(row=5, column= 7, pady = 1)

lblDisplay = Label(calc, text = "Scientific Calculator",

                   font=('Helvetica',30,'bold'),

                   bg='black',fg='white',justify=CENTER)

lblDisplay.grid(row=0, column= 4,columnspan=4)

def iExit():

    iExit = tkinter.messagebox.askyesno("Scientific Calculator",

                                        "Do you want to exit ?")

    if iExit>0:

        root.destroy()

        return

def Scientific():

    root.resizable(width=False, height=False)

    root.geometry("944x568+0+0")

def Standard():

    root.resizable(width=False, height=False)

    root.geometry("480x568+0+0")

menubar = Menu(calc)

filemenu = Menu(menubar, tearoff = 0)

menubar.add_cascade(label = 'File', menu = filemenu)

filemenu.add_command(label = "Standard", command = Standard)

filemenu.add_command(label = "Scientific", command = Scientific)

filemenu.add_separator()

filemenu.add_command(label = "Exit", command = iExit)

editmenu = Menu(menubar, tearoff = 0)

menubar.add_cascade(label = 'Edit', menu = editmenu)

editmenu.add_command(label = "Cut")

editmenu.add_command(label = "Copy")

editmenu.add_separator()

editmenu.add_command(label = "Paste")

root.config(menu=menubar)

root.mainloop()