How to Build Basic GUI Application in Python

In this article we want to learn How to Build Basic GUI Application in Python, so when it comes to building GUI applications with Python you have different options and libraries, we are going to talk about some of them and we will create some practical example about these GUI Frameworks in Python.

Contents hide

1 Why Python for GUI?

2 Build Basic GUI Application in Python TKinter?

2.1 How to install Python TKinter?

3 Build Basic GUI Application in Python PyQt6?

3.1 How to install Python PyQt6?

4 Build Basic GUI Application in Python Kivy?

4.1 How to Install Python Kivy?

5 Which Python GUI Framework is Good?

6 FAQs:

Why Python for GUI?

Python is one of the popular programming languages, Python has easy syntax and large community support. When it comes to GUI development, Python shines with its differtent libraries such as Tkinter, PyQt, and Kivy, each of them offers unique features and advantages. These libraries abstract away much of the complexity of GUI development, and allows you to focus on creating nice and beautiful interfaces.

Build Basic GUI Application in Python TKinter?

So first let’s start building our first basic GUI application with Python TKinter, Tkinter is Python library that helps you create graphical user interfaces (GUIs) for your programs. It provides different components, like buttons, labels and entry fields, that you can use to build windows, menus and other visual elements for your applications.

How to install Python TKinter?

TKinter is already packed with Python, so you don’t need to install that.

So now this is a simple code for building GUI application with Python TKinter

# Import the tkinter module and alias it as 'tk'
import tkinter as tk  

class SimpleApp(tk.Tk):
    def __init__(self):
        # Call the constructor of the superclass (tk.Tk)
        super().__init__()

        # Set the title of the window
        self.title("Codeloop - Simple App")

        # Set the size of the window to 300x200 pixels
        self.geometry("300x200")

        # Create a label widget with text
        self.label = tk.Label(self, text="Codeloop.org")

        # Add the label widget to the window and display it
        self.label.pack()

        # Create a button widget with text and a command
        self.button = tk.Button(self, text="Click me", command=self.on_button_click)  

        # Add the button widget to the window and display it
        self.button.pack() 

    def on_button_click(self):
        # Change the text of the label when the button is clicked
        self.label.config(text="Welcome to codeloop.org")  # Change the text of the label when the button is clicked

if __name__ == "__main__":
    # Create an instance of the SimpleApp class
    app = SimpleApp()

    # Start the Tkinter event loop to display the 
    # window and handle user interactions
    app.mainloop()

# Import the tkinter module and alias it as 'tk'

import tkinter as tk

class SimpleApp(tk.Tk):

def __init__(self):

# Call the constructor of the superclass (tk.Tk)

super().__init__()

# Set the title of the window

self.title("Codeloop - Simple App")

# Set the size of the window to 300x200 pixels

self.geometry("300x200")

# Create a label widget with text

self.label = tk.Label(self, text="Codeloop.org")

# Add the label widget to the window and display it

self.label.pack()

# Create a button widget with text and a command

self.button = tk.Button(self, text="Click me", command=self.on_button_click)

# Add the button widget to the window and display it

self.button.pack()

def on_button_click(self):

# Change the text of the label when the button is clicked

self.label.config(text="Welcome to codeloop.org") # Change the text of the label when the button is clicked

if __name__ == "__main__":

# Create an instance of the SimpleApp class

app = SimpleApp()

# Start the Tkinter event loop to display the

# window and handle user interactions

app.mainloop()

This code creates a simple graphical user interface (GUI) application using Tkinter. When you run the code, it opens a window with a label displaying “Codeloop.org” and a button labeled “Click me”. When you click the button, the label text changes to “Welcome to codeloop.org”. The application continues to run until you close the window. Essentially, it’s a basic example demonstrating how to create a GUI with a label and a button that performs an action when clicked.

Run the code and this will be the result

How to Build Basic GUI Application in Python

Build Basic GUI Application in Python PyQt6?

Now we want to create a simple GUI application with Python, this time we want to use PyQt6 GUI Framework in Python, PyQt6 is a Python library that allows you to create graphical user interfaces (GUIs) for your programs. It’s based on the Qt framework, Qt is a powerful and widely used GUI Framework for building cross-platform applications in C++. With PyQt6, you can design windows, buttons, menus and other visual elements to make your programs more interactive and user-friendly. It provides different features and widgets to help you create complex applications .

How to install Python PyQt6?

For building GUI application in Python PyQt6, first you need to install that and you can use pip for the installation. open your command prompt or terminal and write this command.

pip install PyQt6

1	pip install PyQt6

Now this is basic example of Python GUI application with PyQt6

import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton

class SimpleApp(QMainWindow):
    def __init__(self):
        # Call the constructor of the superclass (QMainWindow)
        super().__init__()

        # Set the title of the window
        self.setWindowTitle("Codeloop - Simple App")

        # Set the position and size of the window
        self.setGeometry(100, 100, 300, 200)

        # Create a label widget with text and
        # set its parent as the main window
        self.label = QLabel("Codeloop.org", self)

        # Move the label to position (100, 50) within the window
        self.label.setGeometry(100,50, 200,200)

        # Create a button widget with text
        # and set its parent as the main window
        self.button = QPushButton("Click me", self)

        # Move the button to position (100, 100) within the window
        self.button.move(100, 100)

        # Connect the button's clicked signal to the on_button_click method
        self.button.clicked.connect(self.on_button_click)

    def on_button_click(self):
        # Change the text of the label when the button is clicked
        self.label.setText("Welcome to codeloop.org")

if __name__ == "__main__":
    # Create an instance of the QApplication class
    app = QApplication(sys.argv)

    # Create an instance of the SimpleApp class
    simple_app = SimpleApp()

    # Display the main window
    simple_app.show()

    # Start the PyQt6 event loop and exit the application when it's terminated
    sys.exit(app.exec())

import sys

from PyQt6.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton

class SimpleApp(QMainWindow):

def __init__(self):

# Call the constructor of the superclass (QMainWindow)

super().__init__()

# Set the title of the window

self.setWindowTitle("Codeloop - Simple App")

# Set the position and size of the window

self.setGeometry(100, 100, 300, 200)

# Create a label widget with text and

# set its parent as the main window

self.label = QLabel("Codeloop.org", self)

# Move the label to position (100, 50) within the window

self.label.setGeometry(100,50, 200,200)

# Create a button widget with text

# and set its parent as the main window

self.button = QPushButton("Click me", self)

# Move the button to position (100, 100) within the window

self.button.move(100, 100)

# Connect the button's clicked signal to the on_button_click method

self.button.clicked.connect(self.on_button_click)

def on_button_click(self):

# Change the text of the label when the button is clicked

self.label.setText("Welcome to codeloop.org")

if __name__ == "__main__":

# Create an instance of the QApplication class

app = QApplication(sys.argv)

# Create an instance of the SimpleApp class

simple_app = SimpleApp()

# Display the main window

simple_app.show()

# Start the PyQt6 event loop and exit the application when it's terminated

sys.exit(app.exec())

In this example, we have used PyQt6 to create a window with a label and a button. When the button is clicked, the label text changes, just like in the Tkinter example. The key differences lie in the way widgets are created and positioned, as well as how the PyQt6 application is executed.

Run the code and this will be the result

If you want learn Python GUI Development with PyQt6, then join the complete course in the link -> Python GUI Development with PyQt6

Build Basic GUI Application in Python Kivy?

Now it is time to create our Python Basic GUI Application with Kivy, so Kivy is an open source Python framework for developing multitouch applications. It allows you to create cross platform applications that can run on different devices, including desktop computers, smartphones and tablets. With Kivy, you can build interactive user interfaces using different range of widgets and layouts. It’s particularly good for creating applications with touch based interactions, and Kivy is one of the popular choice in Android Development field for Python Developers.

How to Install Python Kivy?

For building GUI application in Python Kivy, first you need to install that and you can use pip for the installation. open your command prompt or terminal and write this command.

pip install kivy

1	pip install kivy

Now this is basic example of Python GUI application with Kivy

from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.button import Button
from kivy.uix.boxlayout import BoxLayout

class SimpleApp(App):
    def build(self):
        # Create a vertical BoxLayout to arrange widgets vertically
        layout = BoxLayout(orientation='vertical')

        # Create a Label widget with text and add it to the layout
        self.label = Label(text="Codeloop.org")
        layout.add_widget(self.label)

        # Create a Button widget with text and bind its on_press event to the on_button_click method
        self.button = Button(text="Click me")
        self.button.bind(on_press=self.on_button_click)
        layout.add_widget(self.button)

        # Return the layout as the root widget of the application
        return layout

    def on_button_click(self, instance):
        # Change the text of the label when the button is clicked
        self.label.text = "Welcome to codeloop.org"

if __name__ == "__main__":
    # Create an instance of the SimpleApp class and run the application
    SimpleApp().run()

from kivy.app import App

from kivy.uix.label import Label

from kivy.uix.button import Button

from kivy.uix.boxlayout import BoxLayout

class SimpleApp(App):

def build(self):

# Create a vertical BoxLayout to arrange widgets vertically

layout = BoxLayout(orientation='vertical')

# Create a Label widget with text and add it to the layout

self.label = Label(text="Codeloop.org")

layout.add_widget(self.label)

# Create a Button widget with text and bind its on_press event to the on_button_click method

self.button = Button(text="Click me")

self.button.bind(on_press=self.on_button_click)

layout.add_widget(self.button)

# Return the layout as the root widget of the application

return layout

def on_button_click(self, instance):

# Change the text of the label when the button is clicked

self.label.text = "Welcome to codeloop.org"

if __name__ == "__main__":

# Create an instance of the SimpleApp class and run the application

SimpleApp().run()

In this Kivy example:

We import the necessary classes from the Kivy library.
We define a SimpleApp class that inherits from App, the base class for Kivy applications.
In the build method, we create a layout (a BoxLayout with vertical orientation) and add a Label and a Button widget to it.
We bind the on_press event of the button to the on_button_click method.
When the button is clicked, the on_button_click method changes the text of the label.

Run the code and this will be the result

Which Python GUI Framework is Good?

Choosing the best Python GUI framework depends on different factors such as your project requirements, familiarity with the framework, easy of development, platform compatibility, performance and community support. Each framework has its strengths and weaknesses. Let’s briefly compare the three frameworks:

Tkinter:
- Pros:
  - Comes bundled with Python, so no additional installation is required.
  - Simple and easy to learn, and it is great for beginners.
  - Lightweight and suitable for simple GUI applications.
- Cons:
  - Limited styling options compared to more modern frameworks.
  - May not be as feature rich as other frameworks for complex applications.
PyQt6:
- Pros:
  - Powerful and feature rich, and it offers extensive capabilities for building professional applications.
  - Supports different platforms, including Windows, macOS, Linux, Android and iOS.
  - Offers modern and flexible design, with support for styling and theming.
- Cons:
  - Requires separate installation (although it’s straightforward).
  - Documentation can be less beginner friendly compared to Tkinter.
  - Licensing may be a consideration for commercial projects (PyQt6 is available under GPL and a commercial license).
Kivy:
- Pros:
  - Cross platform support for desktop and mobile applications.
  - Built-in support for touch-based interactions, making it suitable for mobile app development.
  - Highly customizable with support for animations, multi-touch gestures, and more.
- Cons:
  - Requires separate installation and setup.
  - May have a steeper learning curve compared to Tkinter.
  - Performance might not be as high as PyQt6 for certain types of applications.

How to Build Weather App with Python TKinter

FAQs:

Why Python for GUI?

Python is popular, because it has easy syntax and large community support. GUI development in Python is enhanced by libraries like Tkinter, PyQt, and Kivy, each of them offers unique features.

How to Build Basic GUI Application in Python with Tkinter?

Tkinter is Python library for building GUIs. It’s already packed with Python, so no additional installation is needed. A simple code example demonstrates how to create a basic GUI with a label and button.

How to Install Python Tkinter?

Tkinter is already included with Python, there is no need for separate installation.

How to Build Basic GUI Application in Python with PyQt6?

PyQt6 is powerful GUI framework for Python, and it provides large capabilities for building professional applications. You can install that via pip, and i already have created code example demonstrates creating a GUI with PyQt6.

How to Install Python PyQt6?

You can install PyQt6 with pip. The installation command is provided.

How to Build Basic GUI Application in Python with Kivy?

Kivy is an open-source framework for developing multitouch applications in Python. It’s cross platform and suitable for desktop and mobile applications. You can install that via pip.

How to Install Python Kivy?

Kivy can be installed using pip. The installation command is provided.

Subscribe and Get Free Video Courses & Articles in your Email

Why Python for GUI?

Build Basic GUI Application in Python TKinter?

How to install Python TKinter?

Build Basic GUI Application in Python PyQt6?

How to install Python PyQt6?

Build Basic GUI Application in Python Kivy?

How to Install Python Kivy?

Which Python GUI Framework is Good?

FAQs:

Leave a Comment Cancel reply