Python is a fantastic programming language for developing a wide range of useful scripts and programs, including graphical user interfaces (GUIs). A graphical user interface (GUI) allows users to perform operations on a program, platform, device, or application without typing commands or understanding its code. So, if you want to learn to make stunning GUIs with Python, this article is for you.
In this tutorial, we will take a look at the basics of Python GUI. We will learn how to create a simple calculator app for Windows and Android devices and take a look at some of the best Python GUI tools on the market.
Table of Contents
What are useful tools for creating a Python GUI?
There are several tools for Python GUI that Embarcadero offers, including Delphi Community Edition, DelphiFMX, DelphiVCL, PythonFMXBuilder, Delphi4PythonExporter, and PyScripter.
What is DelphiFMX?
DelphiFMX is a natively compiled Python package using the Python4Delphi library. It’s open source and gives Python developers access to Delphi’s FireMonkey (FMX) GUI framework. GUI development with DelphiFMX is possible for many platforms, including Windows, macOS, Linux, and Android.
Embarcadero Delphi’s FireMonkey is a graphical user interface framework for developing native cross-platform applications. It makes use of the GPU via DirectX or OpenGL for hardware-accelerated rendering. It includes a robust styling system and is easily customizable by the user. DelphiFMX for Python requires no prior knowledge of Delphi or Object Pascal.
What is Delphi4PythonExporter?
Delphi4PythonExporter is a critical offering for a thriving Python and Delphi ecosystem. Python developers can save time writing design code in Python by leveraging Delphi’s flagship UI design features. As you design, they can use a WYSIWYG preview, including styles.
Furthermore, users can leverage the features during the design process to tie event methods to various events on the GUI application (for example, OnClick). Finally, Pythoneers can employ this method to scale their large-scale Python GUI application.
Delphi developers can also profit from the Exporter. They can leverage their Delphi expertise to design fantastic apps and then give Python implementations of those applications, providing you with new possibilities and an entirely new dimension.
What is PythonFMXBuilder?
The PythonFMXBuilder is a Python application builder that targets Android applications using DelphiFMX for Python. This enables you to embed a custom Python script in an Android app, deploy it to your phone, and submit it to the app market.
How can I create a simple calculator app using Python and DelphiFMX?
Let’s create a basic calculator application for both Android and desktop devices!
What are the requirements to create a calculator app with Python?
Python, PythonFMXBuilder, Delphi4PythonExporter, Delphi, and any text editor or IDE (PyScripter is recommended) that supports Python are required for this tutorial. If you don’t have these tools installed, check out this article on Python GUI Project Setup to get started.
You can grab the code for this tutorial from our Git repository at: github.com/Embarcadero/PythonBlogExamples/tree/main/Calculator_GUI
How to start a basic form screen for a Python App in Delphi?
Open Delphi CE and create a blank application by navigating to File > New > Multi-Device Application > Blank Application > Ok. Here we have named our project Calculator.
To get a detailed understanding of what each section of the above Delphi IDE means/represents, please go through the free eBook bundle that we developed. This eBook explains the ideology around Delphi-Python EcoSystem, all Python GUI offerings, and much more.
Next, let’s rename our app by right clicking on the form and selecting QuickEdit. Here we will name our form as CalculatorGUI with the caption Calculator Application.
It is important even to name the labels so that it is easier to track them. We even need to add buttons, TButton, that, when clicked, will give appropriate results to the calculation.
Next, rename the text of each label by right-clicking on that label and selecting Quick Edit.
Next, add some color to the form’s background. We can do this by navigating to the Object Inspector and selecting the form’s fill property. After these changes, our form will look much more visually attractive:
We can also check out how our app looks on both Desktop and Android apps. To check this, we can change the Style from Windows to Android. This will change the appearance of our form.
Now double-click on all the buttons on the form. Double-clicking helps to create click methods for each button in the .pas that corresponds to our .fmx form. This helps add a click functionality to each of these buttons later. Next, to each of the button Click methods add at least a single comment (//) which will ensure the method remains as we save the file in Python. There is no need to write any run-time implementation code because we don’t export the run-time implementation using the Delphi4PythonExporter.
How to export a form screen as a Python Script?
You can save your project as a Python script by selecting Tools > Export To Python > Export Current Entire Project.
Delphi will generate two Python scripts, which you can rename to Calculator.py and CalculatorMain.py, in your chosen directory. Along with the Python file is a .pyfmx form that contains all the form’s visual information.
The code in CalculatorMain.py is as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from delphifmx import * from Calculator import CalculatorGUI def main(): Application.Initialize() Application.Title = 'CalculatorGUI' Application.MainForm = CalculatorGUI(Application) Application.MainForm.Show() Application.Run() Application.MainForm.Destroy() if __name__ == '__main__': main() |
Now, let’s look at Calculator.py, where we will be writing the logic of our application:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 |
import os from delphifmx import * class CalculatorGUI(Form): def __init__(self, owner): self.Del = None self.C = None self.Percent = None self.Plus = None self.Seven = None self.Eight = None self.Nine = None self.Minus = None self.Four = None self.Five = None self.Six = None self.Multiply = None self.One = None self.Two = None self.Three = None self.Zero = None self.Dot = None self.Divide = None self.Equals = None self.Calc = None self.Results = None self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Calculator.pyfmx")) def DelClick(self, Sender): pass def CClick(self, Sender): pass def PercentClick(self, Sender): pass def PlusClick(self, Sender): pass def SevenClick(self, Sender): pass def EightClick(self, Sender): pass def NineClick(self, Sender): pass def MinusClick(self, Sender): pass def FourClick(self, Sender): pass def FiveClick(self, Sender): pass def SixClick(self, Sender): pass def MultiplyClick(self, Sender): pass def OneClick(self, Sender): pass def TwoClick(self, Sender): pass def ThreeClick(self, Sender): pass def ZeroClick(self, Sender): pass def DotClick(self, Sender): pass def DivideClick(self, Sender): pass def EqualsClick(self, Sender): pass |
How to run the calculator as a desktop App using the exported Python script?
As you remember, in the code above, all the Click methods like DelClick were left empty. Therefore, we first need to add functionality to all these buttons. So let’s start coding.
First, navigate to your project folder and open up Calculator.py:
Here, you will see all the objects you’ve created and the click methods for each button. For this calculator, we will use the Python eval() function that evaluates any strings that are passed onto it. So create an empty string self.Calculation in the __init__ method of the form. In addition, since the labels in our calculator contain some text, we will also initialize them as empty:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
def __init__(self, owner): self.Del = None self.C = None self.Percent = None self.Plus = None self.Seven = None self.Eight = None self.Nine = None self.Minus = None self.Four = None self.Five = None self.Six = None self.Multiply = None self.One = None self.Two = None self.Three = None self.Zero = None self.Dot = None self.Divide = None self.Equals = None self.Calc = None self.Results = None self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Calculator.pyfmx")) self.Calculation = "" self.Results.Text = "" self.Calc.Text = "" |
Now, we can start coding our click methods. Navigate to each click method and add the relevant character to the self.Calculation string. In addition to this, since we have created a Calc label to display the calculation, add the character to Self.Calc.Text:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
def DelClick(self, Sender): self.Calculation = self.Calculation[:-1] self.Calc.Text = self.Calculation def CClick(self, Sender): self.Calculation = "" self.Calc.Text = self.Calculation self.Results.Text = "" def PercentClick(self, Sender): self.Calculation += "%" self.Calc.Text = self.Calculation def PlusClick(self, Sender): self.Calculation += "+" self.Calc.Text = self.Calculation def SevenClick(self, Sender): self.Calculation += "7" self.Calc.Text = self.Calculation def EightClick(self, Sender): self.Calculation += "8" self.Calc.Text = self.Calculation def NineClick(self, Sender): self.Calculation += "9" self.Calc.Text = self.Calculation def MinusClick(self, Sender): self.Calculation += "-" self.Calc.Text = self.Calculation def FourClick(self, Sender): self.Calculation += "4" self.Calc.Text = self.Calculation def FiveClick(self, Sender): self.Calculation += "5" self.Calc.Text = self.Calculation def SixClick(self, Sender): self.Calculation += "6" self.Calc.Text = self.Calculation def MultiplyClick(self, Sender): self.Calculation += "*" self.Calc.Text = self.Calculation def OneClick(self, Sender): self.Calculation += "1" self.Calc.Text = self.Calculation def TwoClick(self, Sender): self.Calculation += "2" self.Calc.Text = self.Calculation def ThreeClick(self, Sender): self.Calculation += "3" self.Calc.Text = self.Calculation def ZeroClick(self, Sender): self.Calculation += "0" self.Calc.Text = self.Calculation def DotClick(self, Sender): self.Calculation += "." self.Calc.Text = self.Calculation def DivideClick(self, Sender): self.Calculation += "/" self.Calc.Text = self.Calculation |
Like the C and Del functions in most calculators, our calculator does the same. If the Del key is pressed our calculator deletes the last character added, and if the C button is pressed our calculator clears all the calculations. Now, we can code the equals button method. The method uses a try and except block to try and calculate the given expression, using eval, if it is possible. If the added string is correct it shows the result in the self.Results Label, otherwise it shows an "Error" message.
|
1 2 3 4 5 6 |
def EqualsClick(self, Sender): try: self.Results.Text = str(eval(self.Calculation)) except: self.Results.Text = "Error" |
Here is what our final Calculator.py file looks like:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
import os from delphifmx import * class CalculatorGUI(Form): def __init__(self, owner): self.Del = None self.C = None self.Percent = None self.Plus = None self.Seven = None self.Eight = None self.Nine = None self.Minus = None self.Four = None self.Five = None self.Six = None self.Multiply = None self.One = None self.Two = None self.Three = None self.Zero = None self.Dot = None self.Divide = None self.Equals = None self.Calc = None self.Results = None self.LoadProps(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Calculator.pyfmx")) self.Calculation = "" self.Results.Text = "" self.Calc.Text = "" def DelClick(self, Sender): self.Calculation = self.Calculation[:-1] self.Calc.Text = self.Calculation def CClick(self, Sender): self.Calculation = "" self.Calc.Text = self.Calculation self.Results.Text = "" def PercentClick(self, Sender): self.Calculation += "%" self.Calc.Text = self.Calculation def PlusClick(self, Sender): self.Calculation += "+" self.Calc.Text = self.Calculation def SevenClick(self, Sender): self.Calculation += "7" self.Calc.Text = self.Calculation def EightClick(self, Sender): self.Calculation += "8" self.Calc.Text = self.Calculation def NineClick(self, Sender): self.Calculation += "9" self.Calc.Text = self.Calculation def MinusClick(self, Sender): self.Calculation += "-" self.Calc.Text = self.Calculation def FourClick(self, Sender): self.Calculation += "4" self.Calc.Text = self.Calculation def FiveClick(self, Sender): self.Calculation += "5" self.Calc.Text = self.Calculation def SixClick(self, Sender): self.Calculation += "6" self.Calc.Text = self.Calculation def MultiplyClick(self, Sender): self.Calculation += "*" self.Calc.Text = self.Calculation def OneClick(self, Sender): self.Calculation += "1" self.Calc.Text = self.Calculation def TwoClick(self, Sender): self.Calculation += "2" self.Calc.Text = self.Calculation def ThreeClick(self, Sender): self.Calculation += "3" self.Calc.Text = self.Calculation def ZeroClick(self, Sender): self.Calculation += "0" self.Calc.Text = self.Calculation def DotClick(self, Sender): self.Calculation += "." self.Calc.Text = self.Calculation def DivideClick(self, Sender): self.Calculation += "/" self.Calc.Text = self.Calculation def EqualsClick(self, Sender): try: self.Results.Text = str(eval(self.Calculation)) except: self.Results.Text = "Error" |
Finally, open up CalculatorMain.py file and run your application:
Let’s go ahead and test this app. If everything works perfectly then you will be able to run any kind of equation on your application. For example, you can add two numbers easily, and pressing the = sign yields a result:
However, if your mathematical expression to be calculated is invalid you are prompted with an error message:
How to build the calculator as an Android Application using Python and PythonFMXBuilder?
The Delphi4Python Exporter exports the calculator application with initialization logic for a desktop-based application. Therefore, we will be using the PythonFMXBuilder to convert our calculator to an Android app. But before we export our calculator, we need to make some important changes to our code.
Firstly, Android applications are Delphi applications that are initialized automatically. Therefore we don’t need to initialize the application explicitly or to set a title because it will be initialized automatically. So first lets create a new Python file named CalculatorMain_Android.py and paste the contents of CalculatorMain.py in this new file. Next, we don’t need to set the Application.MainForm, but need a variable for the Form. Lastly, just like initialization, we don’t need to run nor destroy the application as it is done automatically by Android.
Here is what our CalculatorMain_Android.py looks like:
|
1 2 3 4 5 6 7 8 9 10 |
from delphifmx import * from Calculator import CalculatorGUI def main(): Application.MainForm = CalculatorGUI(Application) Application.MainForm.Show() if __name__ == '__main__': main() |
Save the file with the changes you’ve made. Next, Open up FMXBuilder and click on Project > New project on the toolbar. Enter the name of the project that you want to build here.
Add your Python files as well as any other supporting project files you used to build your application. We will not import CalculatorMain.py as its only purpose is to run our desktop application:
Next, right-click on CalculatorMain_Andriod.py file and set it to the main file.
We are now ready to convert our app to Android. PythonFMXBuilder gives developers three options for building applications: build, deploy, and run. You can learn more about these options by reading PythonGUI’s e-book.
PythonFMXBuilder allows you to directly install the application on your mobile device. For now, we will build an Android application using a .apk file. To build your file Build project button on the toolbar.
When the .apk is fully generated you will be prompted with a "Build process done" message in the Messages box. You can then check out your generated file in the pathtoPythonFMXBuilderGUIexeFolderappsCalculatorbin folder.
Simply copy and paste this .apk file into your phone’s storage. You will be prompted to install this file if you access it from your phone and click on it. Once completed, your app calculator will be available for use in the same way that any other Android app is.
Here is what our calculator app looks like:
Similar to our desktop app, you can make all kinds of calculations expected from a simple calculator:
Also, similar to our desktop app, trying to evaluate an invalid calculation yields an error:
Are you prepared to create more Apps using Python and DelphiFMX?
Congratulations on making it to the end of this tutorial! Hopefully, it has made you realize how simple it is to build Python GUIs with the right toolkit.
In this tutorial, we saw how building applications is efficient with Delphi. We learned that DelphiFMX is an extremely capable application with numerous capabilities and customization options. It is highly recommended for Windows, Linux, and Mac application developers due to its inherent support for hardware acceleration. DelphiFMX is perfect for building not just calculators, but also other useful applications such as currency converters.
If you want to learn more about Python GUI’s features, you can download the Python GUI getting started e-book. The best part about this package is that you can create multi-device applications. In addition, we also saw how using DelphiFMX library in PyScripter makes Python programming even more fun and easy.
What are the FAQs regarding creating a Python GUI app?
What is Embarcadero?
Embarcadero is the parent company of numerous B2B productivity software companies that enable technical users to complete more tasks in less time.
Embarcadero products are designed for the most skilled programmers in the world who build and support the most important applications. Embarcadero is the developer champion for many clients, supporting them in creating corporate applications that are more secure and scalable faster than with any other solution available. Ninety percent of the Fortune 100 and a global user base of more than three million have trusted Embarcadero’s award-winning products for more than 30 years.
Why is PyScripter a user-favorite IDE?
PyScripter is a free, open-source Python IDE for Windows. Delphi’s Object Pascal and Python were used to create it.
It started as a simple IDE to provide a powerful scripting solution for Delphi applications, which gradually evolved into a full-featured stand-alone Python IDE. PyScripter is written in Delphi and can be extended with Python scripts using Python4Delphi (P4D). It is relatively light compared to other IDEs because it is written in a compiled language.
PyScripter can be used as a syntax highlighting editor, a Python interpreter and debugger, a file explorer, a project manager, and more. In addition, it can be used for creating simple programs as well as more sophisticated APIs and TUIs.
What is Delphi?
Delphi is a high-level programming language that supports an object-oriented paradigm. It is a Rapid Application Development (RAD) paradigm used to create applications ranging from database solutions to mobile applications. Delphi is now widely regarded as the quickest way to develop, compile, package, and deploy cross-platform native applications for Windows, macOS, iOS, Android, and Linux.
Can you build GUIs in Python?
Creating a simple graphical user interface (GUI) that works across multiple platforms can be difficult. But this does not have to be the case. Python and Embarcadero’s DelphiFMX and DelphiVCL packages can be used to create visually appealing user interfaces for you and your users!
What is a multi-device application?
A multi-device application can operate on any platform supported by RAD Studio; multi-device apps are not restricted to desktop or mobile platforms. Multi-device applications use two of RAD Studio’s three core libraries: FireMonkey and RTL.
