Python Server Programming: Developing Desktop Applications with PyQt5

Python has become a very popular programming language, and it performs very well in server-side programming. Its high readability and simple syntax bring great convenience to programming. However, in terms of programming desktop applications, Python has encountered some difficulties in the design of GUI interfaces. But now with PyQt5, desktop application development in Python has become easier.

PyQt5 is a widely used Python library that can be used to create desktop applications. PyQt5 is developed based on the Qt framework. Qt is a cross-platform development framework that can run programs on multiple platforms. PyQt5 can be used not only to create desktop applications, but it also has many other applications, such as creating web applications and games.

In this article, we will explore how to develop a simple desktop application using PyQt5, using Python as the server and creating a GUI interface using PyQt5. We will build a simple calculator application where the user can enter mathematical equations and calculate the result. let's start!

To start writing our application, we need installers for Python3 and PyQt5. We can get the Python3 installer from the Python official website and download the PyQt5 installer from the PyQt5 official website.

After the installation is complete, we can start writing our code. First, we need to import the PyQt5 module and create an application window. The following code will create a blank window.

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow

app = QApplication(sys.argv)
win = QMainWindow()
win.show()
sys.exit(app.exec_())

In this example, we first imported the sys module and the QApplication and QMainWindow classes. Next we create a QApplication object, which is the core object of our application. We also created a QMainWindow object and used the show() method to display the application's window. Finally, use the sys.exit() method to ensure that the program exits safely.

Now we can add some widgets to the window, such as buttons and text boxes, etc. Our application requires two text boxes, one for entering calculations and one for displaying the results, and some buttons for performing arithmetic operations.

Here is the code for our application:

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QLineEdit, QPushButton, QVBoxLayout


class Calculator(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle('Calculator')
        
        # 创建两个文本框
        self.input_box = QLineEdit()
        self.result_box = QLineEdit()
        self.result_box.setReadOnly(True)
        
        # 创建按钮
        self.btn_1 = QPushButton('1')
        self.btn_2 = QPushButton('2')
        self.btn_3 = QPushButton('3')
        self.btn_4 = QPushButton('4')
        self.btn_5 = QPushButton('5')
        self.btn_6 = QPushButton('6')
        self.btn_7 = QPushButton('7')
        self.btn_8 = QPushButton('8')
        self.btn_9 = QPushButton('9')
        self.btn_0 = QPushButton('0')
        self.btn_add = QPushButton('+')
        self.btn_sub = QPushButton('-')
        self.btn_mul = QPushButton('*')
        self.btn_div = QPushButton('/')
        self.btn_calculate = QPushButton('=')
        self.btn_clear = QPushButton('Clear')
        
        # 将按钮连接到处理程序
        self.btn_1.clicked.connect(lambda: self.on_click('1'))
        self.btn_2.clicked.connect(lambda: self.on_click('2'))
        self.btn_3.clicked.connect(lambda: self.on_click('3'))
        self.btn_4.clicked.connect(lambda: self.on_click('4'))
        self.btn_5.clicked.connect(lambda: self.on_click('5'))
        self.btn_6.clicked.connect(lambda: self.on_click('6'))
        self.btn_7.clicked.connect(lambda: self.on_click('7'))
        self.btn_8.clicked.connect(lambda: self.on_click('8'))
        self.btn_9.clicked.connect(lambda: self.on_click('9'))
        self.btn_0.clicked.connect(lambda: self.on_click('0'))
        self.btn_add.clicked.connect(lambda: self.on_click('+'))
        self.btn_sub.clicked.connect(lambda: self.on_click('-'))
        self.btn_mul.clicked.connect(lambda: self.on_click('*'))
        self.btn_div.clicked.connect(lambda: self.on_click('/'))
        self.btn_calculate.clicked.connect(self.calculate)
        self.btn_clear.clicked.connect(self.clear)
        
        # 创建垂直布局
        vbox = QVBoxLayout()
        vbox.addWidget(self.input_box)
        vbox.addWidget(self.result_box)
        vbox.addWidget(self.btn_1)
        vbox.addWidget(self.btn_2)
        vbox.addWidget(self.btn_3)
        vbox.addWidget(self.btn_4)
        vbox.addWidget(self.btn_5)
        vbox.addWidget(self.btn_6)
        vbox.addWidget(self.btn_7)
        vbox.addWidget(self.btn_8)
        vbox.addWidget(self.btn_9)
        vbox.addWidget(self.btn_0)
        vbox.addWidget(self.btn_add)
        vbox.addWidget(self.btn_sub)
        vbox.addWidget(self.btn_mul)
        vbox.addWidget(self.btn_div)
        vbox.addWidget(self.btn_calculate)
        vbox.addWidget(self.btn_clear)
        
        # 设置小部件的布局
        self.setLayout(vbox)
        
        self.show()
    
    def on_click(self, key):
        self.input_box.setText(self.input_box.text() + key)
        
    def calculate(self):
        try:
            result = eval(self.input_box.text())
            self.result_box.setText(str(result))
        except:
            self.result_box.setText('Error')
            
    def clear(self):
        self.input_box.setText('')
        self.result_box.setText('')


if __name__ == '__main__':
    app = QApplication(sys.argv)
    win = QMainWindow()
    
    calc = Calculator()
    win.setCentralWidget(calc)
    
    win.setWindowTitle('Calculator')
    win.show()
    
    sys.exit(app.exec_())

In this example, we created a class called Calculator, which inherits from QWidget. In the constructor, we set a title for the application window and create two text boxes for entering calculations and displaying results. We also created some buttons that perform various arithmetic operations.

We use QVBoxLayout to set the vertical layout of the widgets in the application. This layout is then set to our widget using the setLayout() method.

We also define three other methods in the code. The on_click() method is a button event handler that adds the character the user clicked on the button to the input box. The calculate() method performs a mathematical calculation and displays the results in the results box. If the user input is not a valid calculation, the result box will display an error message. The clear() method will clear everything in the input and result boxes.

Finally, in the main function, we create a QMainWindow object and set the Calculator object as its center widget. Use the setWindowTitle() method to set the title of the application, and finally use the show() method to display the window.

Now we can run the application. Run the python program in the terminal and save it as a .py file and then execute it.

This is a simple calculator application, but demonstrates the ability to develop very powerful desktop applications using PyQt5. PyQt5 has many other features, such as support for rich Qt styles and themes, extending application functions through the PyQt5 plug-in mechanism, etc.

In short, PyQt5 is a very powerful Python library that can be used to create various types of desktop applications. If you are interested in developing desktop applications or want to learn more about PyQt5, it is recommended to read the official documentation of PyQt5 and its sample code.

The above is the detailed content of Python Server Programming: Developing Desktop Applications with PyQt5. For more information, please follow other related articles on the PHP Chinese website!