Hyper complet ! Guide d'utilisation du framework d'interface graphique Python PyQt5 !

Frameworks GUI communs

• PyQt5 : Qt est une bibliothèque d'interface utilisateur graphique C++ multiplateforme. QT appartenait autrefois à Nokia, puis vendu à Digia Oyj, une société de logiciels finlandaise. PyQt5 est une interface Python basée sur Qt5 de Digia et se compose d'un ensemble de modules Python. PyQt5 lui-même compte plus de 620 classes et 6 000 fonctions et méthodes. Peut fonctionner sur plusieurs plates-formes, notamment : Unix, Windows et Mac OS.
• Pyside6 : Pyside est le package Python officiellement fourni par QT Company. La version précédente était Pyside2, qui correspond à QT5. Les règles de nommage de la dernière version ont été ajustées et modifiées en Pyside6, qui correspond à la version QT6. Le produit officiel étant relativement prometteur, l'inconvénient est qu'il est sorti tardivement et qu'il n'y a pas autant d'informations sur Internet que PyQt5.
  
• Tkinter : le framework GUI intégré de Python, implémenté à l'aide de TCL. L'interpréteur TCL est intégré à Python. Lorsque vous l'utilisez, vous n'avez pas besoin d'installer de packs d'extension supplémentaires. L'inconvénient est que la disposition de l'interface utilisateur est entièrement implémentée par code, qu'il n'y a que 15 composants communs et que l'effet d'affichage est simple.
• PySimpleGUI : PySimpleGUI est un wrapper pour Tkinter. L'implémentation d'une interface graphique personnalisée à l'aide de PySimpleGUI nécessite beaucoup moins de code que l'écriture de la même interface graphique directement à l'aide de Tkinter.
  
• WxPython : wxPython est une liaison de langage Python pour la populaire bibliothèque d'outils GUI multiplateforme wxWidgets. Il est largement utilisé, multiplateforme, écrit en C++ et comporte peu de documents. Les utilisateurs devront peut-être apporter quelques ajustements au code de l'interface graphique sur différentes plates-formes en fonction du contenu de la programmation. Il est difficile de résoudre les problèmes lorsqu'on les rencontre. Le contrôle de la disposition du code n'est pas intuitif.
  
• Wax : Basé sur wxPython, un package conçu pour surmonter les problèmes de wxPython.
  
• Kivy : Principalement destiné aux programmes multi-touch, aux smartphones et tablettes, etc. Il peut également être utilisé sur des systèmes sans fonctions d'écran tactile. Il prend en charge toutes les plateformes (Windows, Linux, Mac OS X, Android et iOS.) utilisant. Python et cython, le support chinois est médiocre, vous devez télécharger la bibliothèque chinoise et formuler le chemin vous-même.
  
• BeeWare : Écrivez une fois. Doit être utilisé avec Kivy.
  
• Toga : une boîte à outils GUI pour développer des applications natives à l'aide de Python. Toga se compose d'une bibliothèque de composants de base avec des interfaces partagées pour simplifier le développement d'interfaces graphiques indépendantes de la plate-forme. Toga est disponible pour Mac OS, Windows, Linux (GTK) et les plateformes mobiles telles qu'Android et iOS.
  
• Eel : une bibliothèque Python légère pour créer de simples applications GUI HTML/JS hors ligne similaires à (mais plus légères que) Electron, avec un accès complet aux fonctionnalités Python et aux autorisations des bibliothèques.
  
• Flexx : Une boîte à outils Python pure pour créer des applications d'interface graphique. Il utilise la technologie Web pour le rendu de l'interface. Vous pouvez utiliser Flexx pour créer des applications de bureau et vous pouvez également exporter une application vers un document HTML autonome. Parce qu'il est développé en Python pur, Flexx est multiplateforme. Tout ce dont vous avez besoin est Python et un navigateur pour exécuter.
  
• pywebview est un wrapper multiplateforme léger autour du composant webview qui permet d'afficher le contenu HTML dans sa propre fenêtre GUI native. Il vous permet d'utiliser les technologies Web dans des applications de bureau tout en cachant autant que possible le fait qu'un navigateur est utilisé pour construire l'interface graphique.
  
• enaml : Un framework Python qui vous permet d'implémenter des interfaces GUI de haute qualité avec un minimum d'effort. C'est également un langage de programmation unique. enaml combine un langage déclaratif avec un système de mise en page basé sur des contraintes, permettant aux utilisateurs de définir facilement des mises en page flexibles de l'interface utilisateur. les applications enaml peuvent s'exécuter sur n'importe quelle plate-forme prenant en charge Python et Qt.

Réflexions personnelles : il y a trop de choses à apprendre, alors apprenez d'abord PyQt5, car il y a beaucoup d'informations, puis apprenez pyside6 si vous avez assez d'énergie. Enfin, jetez un œil à PySimpleGUI pour voir si vous pouvez en résoudre certaines. problèmes simples.

Introduction à PyQt5

PyQt est une implémentation en langage Python du framework Qt. Il a été développé par Riverbank Computing et est l'une des bibliothèques GUI les plus puissantes. PyQt fournit une collection bien conçue de contrôles de fenêtre. Chaque contrôle PyQt correspond à un contrôle Qt. Par conséquent, l'interface API de PyQt est très proche de l'interface API de Qt, mais PyQt n'utilise plus le système QMake et la macro Q_OBJECT.

PyQt5 fournit des certificats de version GPL et de version commerciale. Les développeurs gratuits peuvent utiliser la licence GPL gratuite. Si vous devez utiliser PyQt pour des applications commerciales, vous devez acheter une licence commerciale.

Les fonctionnalités de PyQt5 sont les suivantes :

• Ensemble de contrôles GUI basés sur Qt hautes performances.
• Peut fonctionner sur plusieurs plates-formes sur les systèmes Linux, Windows et Mac OS.
  
• Utilisez le mécanisme de signal et de fente pour la communication.
  
• Encapsule complètement la bibliothèque Qt.
  
• Vous pouvez utiliser un IDE mature pour la conception d'interfaces et générer automatiquement du code Python exécutable.
  
• Fournit un ensemble complet de commandes de fenêtre.
  
• PyQt5 est composé d'une série de modules Python, avec plus de 620 classes, 6000 fonctions et méthodes. Les principaux modules sont les suivants :
  
• QtCore : Contient les fonctions principales non-GUI. Principalement utilisé avec le temps, les fichiers et dossiers, diverses données, flux, URL, fichiers de classe MIME, processus et threads.
  
• QtGui : comprend le système de fenêtres, la gestion des événements, les images 2D, la peinture de base, les polices et les classes de texte.
  
• QtWidgets : contient une série d'éléments d'interface utilisateur pour créer des applications de bureau.
  
• QtMultimedia : Contient des classes pour traiter le contenu multimédia et appeler l'API de la caméra.
  
• QtBluetooth : Contient des cours pour trouver et se connecter à Bluetooth.
  
• QtNetwork : contient des cours de programmation réseau. Ces outils peuvent rendre le développement TCP/IP et UDP plus pratique et fiable.
  
• QtPositioning : Contient des classes de positionnement pouvant utiliser le satellite, le WiFi ou même le texte.
  
• Enginio : Contient des classes pour saisir et gérer Qt Cloud via le client.
  
• QtWebSockets : Contient la classe du protocole WebSocket.
  
• QtWebKit : Contient un navigateur web basé sur WebKit2.
  
• QtWebKitWidgets : Contient des classes basées sur WebKit1 de QtWidgets.
  
• QtXml : contient des classes pour le traitement du XML et fournit des outils pour les API SAX et DOM.
  
• QtSvg : Fournit une classe pour afficher le contenu SVG. Scalable Vector Graphics (SVG) est un format graphique basé sur Extensible Markup Language (XML) pour décrire des graphiques vectoriels bidimensionnels (cette phrase vient de Wikipédia).
  
• QtSql : Fournit des outils de traitement des bases de données.
  
• QtTest : Fournit des outils pour tester les applications PyQt5.
  

Installation de PyQt5

Étant donné que fbs sera utilisé pour l'empaquetage plus tard, fbs peut avoir des problèmes de compatibilité avec Python 3.7 et les versions ultérieures, j'ai donc choisi Python 3.6.8 pour créer l'ensemble de l'environnement. Le contenu principal est : Python + PyCharm + PyQt5

Installer PyQt5

pip install pyqt5
pip install pyqt5-tools

Parmi eux, pyqt5-tools est l'outil de conception d'interface par glisser-déposer de Qt Designer. L'erreur suivante peut être signalée pendant le processus d'installation :

qt5-tools 5.15.2.1.2 has requirement click~=7.0, but you'll have click 8.0.1 which is incompatible.

Solution :

pip install click~=7.0

Configuration de Qt Designer

Qt Designer place les contrôles en faisant glisser et en affichant les effets des contrôles en temps réel pour une conception rapide de l'interface utilisateur.

La composition de l'écran entier :

• La "Widget Box" à gauche est composée de divers composants qui peuvent être glissés librement
• La forme "MainWindow - sans titre" au milieu est le canevas
  
• Celui en haut à droite "Inspecteur d'objets" peut afficher la structure de l'interface utilisateur actuelle
  
• "Éditeur de propriétés" au milieu à droite peut définir les propriétés du composant actuellement sélectionné
  
• "Navigateur de ressources" en bas à droite peut ajouter divers matériaux, tels que des images, des arrière-plans, etc.
  

Le fichier .ui (essentiellement un fichier au format XML) est enfin généré, qui peut être utilisé directement ou converti en fichier .py via l'outil pyuic5.

Configuration QtDisigner

Dans Pycharm, ouvrez Fichier – Paramètres – Outils – Outils externes, cliquez sur + Créer un outil, la configuration est la suivante :

Name: QtDisigner
Program : D:Program FilesPython36Libsite-packagesqt5_applicationsQtbindesigner.exe # 请根据实际修改
Working directory: $FileDir$

Configuration PyUIC

PyUIC convertit principalement les fichiers .ui générés par Qt Designer Remplacez-le par un fichier .py.

Dans Pycharm, ouvrez Fichier – Paramètres – Outils – Outils externes, cliquez sur + Créer un outil, la configuration est la suivante :

Name: PyUIC
Program : D:Program FilesPython36python.exe # 当前Python目录，请根据实际修改
Arguments: -m PyQt5.uic.pyuic $FileName$ -o $FileNameWithoutExtension$.py
Working directory: $FileDir$

Configuration PyRCC

PyRCC remplace principalement le fichier de ressources .qrc écrit par un fichier .py. Dans Pycharm, ouvrez Fichier – Paramètres – Outils – Outils externes, cliquez sur + Créer un outil, la configuration est la suivante :

Name: PyRCC
Program: D:Program FilesPython36pyrcc5.exe # 当前rcc工具目录，请根据实际修改
Arguments: $FileName$ -o $FileNameWithoutExtension$_rc.py
Working directory: $FileDir$

Exemple d'utilisation de PyQt5

Créez une interface vierge :

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel
app = QApplication(sys.argv)
win = QMainWindow()
win.setGeometry(400, 400, 400, 300)
win.setWindowTitle("Pyqt5 Tutorial")
win.show()
sys.exit(app.exec_())

où :

•  Qapplication()：每个GUI都必须包含一个Qapplication，argv表示获取命令行参数，如果不用获取，则可以使用[]代替。
•  QMainWindow()：类似一个容器（窗口）用来包含按钮、文本、输入框等widgets。arg标识可以获取命令行执行时的参数。
  
•  SetGeometry是用来定义 QMainWindow() 窗口的尺寸， 语法：setGeometry(x, y, width, height )，其中x,y为屏幕上的坐标点。
  
•  show()：用来显示窗口
  
•  exit(app.exec_())：设置窗口一直运行指导使用关闭按钮进行关闭
  

PyQt5支持的常见Widgets有：

从上到下，从左到右依次为：Qlabel、QcomboBox、QcheckBox、QradioButton、QpushButton、QtableWidget、QlineEdit、Qslider、QProgressBar

对于使用Pyqt5设置文本内容，我们使用Qlabel：

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QLabel
app = QApplication(sys.argv)
win = QMainWindow()
win.setGeometry(400, 400, 400, 300)
win.setWindowTitle("Pyqt5 Tutorial")
# Label Text
label = QLabel(win)
label.resize(200, 100)
label.setText("Hi this is Pyqt5")
label.move(100, 100)
win.show()
sys.exit(app.exec_())

按钮与事件：

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton
def click():
 print("Hy Button is clicked!")
app = QApplication(sys.argv)
win = QMainWindow()
win.setGeometry(400, 400, 400, 300)
win.setWindowTitle("Pyqt5 Tutorial")
# Button
button = QPushButton(win)
button.resize(200, 100)
button.setText("Hi! Click Me")
button.move(100, 100)
button.clicked.connect(click)
win.show()
sys.exit(app.exec_())

button.clicked.connect() 在按钮点击后执行特定的事件。

PyQt5实战

实战项目：简易的天气查询软件

1、使用Qt Designer设计一个界面

用到的控件有Button, GroupBox, Label,ComboBox,TextEdit，同时定义了两个按钮queryBtn及clearBtn，分别用来查询及清空天气数据。我们需要绑定槽函数，方法如下：

•  在Qt Designer右下角选择 信号/槽编辑器，点击+号新增
•  分别选择queryBtn及clearBtn，选择信号 clicked(), 接收者 Dialog 及槽 accept()，（槽函数这里不知道如何定义，后期在代码里再进行修改）
  

以上完成后保存为Weather.ui文件。

2、转换.ui文件为.py文件

PyQt5支持直接使用.ui文件：

import sys
from PyQt5 import QtWidgets, uic
app = QtWidgets.QApplication(sys.argv)
window = uic.loadUi("mainwindow.ui")
window.show()
app.exec()

但是为了更好的自定义及修改上面的槽函数，可以使用External Tools – PyUIC，即可生成Weather.py，实际运行命令如下：

D:Program FilesPython36python.exe -m PyQt5.uic.pyuic Weather.ui -o Weather.py

其中，我们需要把两个按钮绑定的槽函数：

# self.queryBtn.clicked.connect(Dialog.accept)
# self.clearBtn.clicked.connect(Dialog.accept)
# 修改为：
self.queryBtn.clicked.connect(Dialog.queryWeather)
self.clearBtn.clicked.connect(Dialog.clearText)

最终的Weather.py内容如下：

# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'Weather.ui'
#
# Created by: PyQt5 UI code generator 5.15.4
#
# WARNING: Any manual changes made to this file will be lost when pyuic5 is
# run again.Do not edit this file unless you know what you are doing.
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_Dialog(object):
 def setupUi(self, Dialog):
 Dialog.setObjectName("Dialog")
 Dialog.resize(600, 600)
 self.groupBox = QtWidgets.QGroupBox(Dialog)
 self.groupBox.setGeometry(QtCore.QRect(30, 20, 551, 511))
 self.groupBox.setObjectName("groupBox")
 self.label_2 = QtWidgets.QLabel(self.groupBox)
 self.label_2.setGeometry(QtCore.QRect(20, 30, 31, 16))
 self.label_2.setObjectName("label_2")
 self.comboBox = QtWidgets.QComboBox(self.groupBox)
 self.comboBox.setGeometry(QtCore.QRect(70, 30, 87, 22))
 self.comboBox.setObjectName("comboBox")
 self.comboBox.addItem("")
 self.comboBox.addItem("")
 self.comboBox.addItem("")
 self.textEdit = QtWidgets.QTextEdit(self.groupBox)
 self.textEdit.setGeometry(QtCore.QRect(20, 70, 491, 411))
 self.textEdit.setObjectName("textEdit")
 self.queryBtn = QtWidgets.QPushButton(Dialog)
 self.queryBtn.setGeometry(QtCore.QRect(490, 560, 93, 28))
 self.queryBtn.setObjectName("queryBtn")
 self.clearBtn = QtWidgets.QPushButton(Dialog)
 self.clearBtn.setGeometry(QtCore.QRect(30, 560, 93, 28))
 self.clearBtn.setObjectName("clearBtn")
 self.retranslateUi(Dialog)
 self.clearBtn.clicked.connect(Dialog.clearText)
 self.queryBtn.clicked.connect(Dialog.queryWeather)
 QtCore.QMetaObject.connectSlotsByName(Dialog)
 def retranslateUi(self, Dialog):
 _translate = QtCore.QCoreApplication.translate
 Dialog.setWindowTitle(_translate("Dialog", "Dialog"))
 self.groupBox.setTitle(_translate("Dialog", "城市天气预报"))
 self.label_2.setText(_translate("Dialog", "城市"))
 self.comboBox.setItemText(0, _translate("Dialog", "北京"))
 self.comboBox.setItemText(1, _translate("Dialog", "苏州"))
 self.comboBox.setItemText(2, _translate("Dialog", "上海"))
 self.queryBtn.setText(_translate("Dialog", "查询"))
 self.clearBtn.setText(_translate("Dialog", "清空"))

3、调用MainDialog

在MainDialog中调用界面类Ui_Dialog，然后在其中中添加查询天气的业务逻辑代码，这样就做到了界面显示和业务逻辑的分离。新增demo.py文件， 在MainDialog类中定义了两个槽函数queryWeather()和clearText(),以便在界面文件Weather.ui中定义的两个按钮(queryBtn 和clearBtn) 触发clicked 信号与这两个槽函数进行绑定。

完整代码如下：

import sys
import Weather
from PyQt5.QtWidgets import QApplication, QDialog
import requests
class MainDialog(QDialog):
 def __init__(self, parent=None):
 super(QDialog, self).__init__(parent)
 self.ui = Weather.Ui_Dialog()
 self.ui.setupUi(self)
 def queryWeather(self):
 cityName = self.ui.comboBox.currentText()
 cityCode = self.getCode(cityName)
 r = requests.get(
 "https://restapi.amap.com/v3/weather/weatherInfo?key=f4fd5b287b6d7d51a3c60fee24e42002&city={}".format(
 cityCode))
 if r.status_code == 200:
 data = r.json()['lives'][0]
 weatherMsg = '城市：{}n天气：{}n温度：{}n风向：{}n风力：{}n湿度：{}n发布时间：{}n'.format(
 data['city'],
 data['weather'],
 data['temperature'],
 data['winddirection'],
 data['windpower'],
 data['humidity'],
 data['reporttime'],
 )
 else:
 weatherMsg = '天气查询失败，请稍后再试！'
 self.ui.textEdit.setText(weatherMsg)
 def getCode(self, cityName):
 cityDict = {"北京": "110000",
 "苏州": "320500",
 "上海": "310000"}
 **return** cityDict.get(cityName, '101010100')
 def clearText(self):
 self.ui.textEdit.clear()
if __name__ == '__main__':
 myapp = QApplication(sys.argv)
 myDlg = MainDialog()
 myDlg.show()
 sys.exit(myapp.exec_())

运行demo.py并执行查询后的效果：

4、将代码打包成exe文件

将.py文件打包成可执行的exe在Python中称为freezing，常用的工具有：PyInstaller, py2exe, cx_Freeze, bbfreze, py2app等。功能对比：

•  py2exe：软件更新已经不活跃，因此也就略过。
  
•  pyinstaller：明确支持win8、win10、理论上支持win7,，支持apple Macos, linux。pyinsaller可以打包成文件夹形式内含exe入口执行文件的形式，也可以是一个单独的exe文件。
  
• fbs：基于PyInstaller，使用起来更加方便
  

这里选择了fbs来打包。fbs的安装方法：

pip install fbs

使用方法，在命令行中输入：

fbs startproject

执行完成后需要输入一些APP的名称等。完成后会生成如下目录：

将刚才编写的PyQt5的代码（demo.py和Weather.py）拖到src/main/python文件夹下，删除原有的main.py，并将demo.py修改为main.py。然后打开 main.py，在文件头部添加如下代码：

from fbs_runtime.application_context.PyQt5 import ApplicationContext
```
完成后执行：
```
fbs freeze
```
即可实现打包。生成的exe可执行文件在targetMyApp文件下。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!