Tutoriel PyQt5 avec exemples : Concevoir une interface graphique à l'aide de PyQt dans Python

PyQt est un logiciel libre développé et maintenu par Riverbank Computing, une société basée en Angleterre, tandis que Qt est développé par une société finlandaise appelée The Qt Company.

Caractéristiques de PyQT

Voici les fonctionnalités importantes de PyQt :

Apprenez PyQt, qui comprend plus de six cents classes couvrant une gamme de fonctionnalités telles que

• Interfaces utilisateur graphiques
• Bases de données SQL
• Boîtes à outils Web
• Traitement XML
• Networking

Ces fonctionnalités peuvent être combinées pour créer des interfaces utilisateur avancées ainsi que des applications autonomes. De nombreuses grandes entreprises de tous secteurs utilisent Qt. Quelques exemples sont LG, Mercedes, AMD, Panasonic, Harman, etc.

Versions PyQt

PyQt est disponible en deux éditions, PyQt4 et PyQt5. PyQt4 fournit un code de colle pour lier les versions 4.x et 5.x du framework Qt tandis que PyQt5 fournit une liaison pour uniquement les versions 5.x. Par conséquent, PyQt5 n’est pas rétrocompatible avec les modules obsolètes de l’ancienne version. Dans ce didacticiel Qt GUI, PyQt5 sera utilisé pour la démonstration d'exemples. Hormis ces deux versions,

Riverbank Computing fournit également PyQt3D, les liaisons Python pour le framework Qt3D. Qt3D est un framework d'application utilisé pour créer des systèmes de simulation en temps réel avec un rendu 2D/3D.

Comment installer PyQt5

Dans ce tutoriel PyQt5, nous verrons les deux manières d'installer PyQt :

• Utiliser les fichiers Wheel
• Construire et installer à partir de la source

Qt (prononcé mignon) est un système complexe et la base de code PyQt contient des C++ et le Python code sous le capot. Par conséquent, il s'agit d'un processus compliqué à construire et à installer à partir de la source par rapport à d'autres bibliothèques Python. Cependant, vous pouvez facilement installer PyQt5 à l'aide de wheels.

Installation avec roues

Les roues sont la nouvelle norme Python format d'emballage et de distribution. En termes simples, une roue est une archive ZIP avec un nom spécial et .tout extension de fichier. Les roues peuvent être installées à l'aide de pip (Pythonle gestionnaire de paquets de), qui est inclus par défaut dans les versions récentes de Python.

Donc, si vous avez Python 3.4 ou une version ultérieure installée, vous disposez déjà de pip. Si, toutefois, vous utilisez une version plus ancienne de Python, vous devez télécharger et installer pip avant de continuer. Vous pouvez rechercher des instructions à ce sujet sur ce lien : https://pypi.org/project/pip/.

Pour installer PyQt5,

Étape 1) Ouvrez l'invite de commande.
Ouvrez l'invite de commande ou PowerShell dans votre Windows machine.

Étape 2) Tapez ce qui suit.

 pip install PyQt5

Étape 3) Installation réussie.
Cette étape de ce didacticiel PyQt5 téléchargera le package PyQt5 whl (environ 50 Mo) et l'installera sur votre système.

Alternativement, vous pouvez également télécharger un Windows binaire pour la version de python installée sur votre ordinateur.

Une fois terminé, passez à la section suivante de ce didacticiel PyQt5 pour écrire votre première application GUI.

PyQt de base Concepts et programmes

Maintenant que vous avez installé avec succès PyQt5 sur votre ordinateur, vous êtes prêt à écrire Python Applications de conception d'interface graphique.

Commençons par une application simple dans ce tutoriel PyQt5 qui affichera une fenêtre vide sur votre écran.

Allumez votre python IDLE et saisissez ce qui suit :

Programme 1

import sys
from PyQt5.QtWidgets import QApplication, QWidget
if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = QWidget()
    w.resize(300,300)
    w.setWindowTitle("Guru99")
    w.show()
    sys.exit(app.exec_())

Enregistrez-le sous app.py (le nom n'a pas d'importance) et appuyez sur F5 pour exécuter le programme. Vous pouvez également double-cliquer simplement sur votre fichier enregistré pour lancer l'application. Si vous avez tout fait correctement, une nouvelle fenêtre s'ouvrira avec le titre Guru99 comme indiqué ci-dessous.

Super! Ça marche. Ce n'est pas grand-chose, mais c'est suffisant pour comprendre les bases. Maintenant, dans ce didacticiel PyQt, voyons en détail ce que fait chacune des lignes de votre programme.

from PyQt5.QtWidgets import QApplication, QWidget

Cette instruction importe tous les modules dont vous avez besoin pour créer une interface graphique dans l'espace de noms actuel. Le module QtWidgets contient tous les principaux widgets que vous utiliserez dans ce Python Tutoriel Qt.

app = QApplication(sys.argv)

Ici, vous créez un objet de la classe QApplication. Cette étape est une nécessité pour PyQt5 ; chaque application d'interface utilisateur doit créer une instance de QApplication, comme une sorte de point d'entrée dans l'application. Si vous ne le créez pas, des erreurs seront affichées.

sys.argv est la liste des paramètres de ligne de commande que vous pouvez transmettre à l'application lors de son lancement via le shell ou lors de l'automatisation de l'interface.

Dans cet exemple PyQt5, vous n'avez transmis aucun argument à QApplications. Par conséquent, vous pouvez également le remplacer par le code ci-dessous sans même avoir à importer le module sys.

app = QApplication([])

w = QWidget()

Ensuite, nous créons un objet de la classe QWidget. QWidget est la classe de base de tous les objets de l'interface utilisateur de Qt, et pratiquement tout ce que vous voyez dans une application est un widget. Cela inclut les boîtes de dialogue, les textes, les boutons, les barres, etc. La fonctionnalité qui vous permet de concevoir des interfaces utilisateur complexes est que les widgets peuvent être imbriqués, c'est-à-dire que vous pouvez avoir un widget à l'intérieur d'un widget, qui se trouve dans un autre widget. Vous verrez cela en action dans la section suivante.

w.resize(300,300)

La méthode resize de la classe QWidget vous permet de définir les dimensions de n'importe quel widget. Dans ce cas, vous avez redimensionné la fenêtre à 300 px sur 300 px.

Ici, vous devez vous rappeler que les widgets peuvent être imbriqués ensemble, le widget le plus externe (c'est-à-dire le widget sans parent) est appelé une fenêtre.

w.setWindowTitle("Guru99")

La méthode setWindowTitle() vous permet de passer une chaîne comme argument qui définira le titre de la fenêtre sur la chaîne que vous transmettez. Dans l'exemple PyQt5, la barre de titre affichera Guru99.

w.show()

show() affiche simplement le widget sur l'écran du moniteur.

sys.exit(app.exec_())

La méthode app.exec_() démarre le Qt/C++ boucle d'événements. Comme vous le savez, PyQt est en grande partie écrit en C++ et utilise le mécanisme de boucle d'événements pour implémenter l'exécution parallèle. app.exec_() passe le contrôle à Qt qui quittera l'application uniquement lorsque l'utilisateur la fermera depuis l'interface graphique. C'est pourquoi ctrl+c ne quittera pas l'application comme dans d'autres programmes Python. Étant donné que Qt a le contrôle sur l'application, les événements Python ne sont pas traités à moins que nous ne les configurions à l'intérieur de l'application. Notez également que la méthode exec a un trait de soulignement dans son nom ; c'est parce que exec() était déjà un mot-clé en Python et que le trait de soulignement résout le conflit de nommage.

Au-delà des fenêtres vides

Dans la section précédente, vous avez vu comment créer un widget de base dans Qt. Il est maintenant temps de créer des interfaces plus complexes avec lesquelles les utilisateurs peuvent véritablement interagir. Encore une fois, allumez votre IDLE et écris ce qui suit.

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QMessageBox

def dialog():
    mbox = QMessageBox()

    mbox.setText("Your allegiance has been noted")
    mbox.setDetailedText("You are now a disciple and subject of the all-knowing Guru")
    mbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
            
    mbox.exec_()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = QWidget()
    w.resize(300,300)
    w.setWindowTitle("Guru99")
    
    label = QLabel(w)
    label.setText("Behold the Guru, Guru99")
    label.move(100,130)
    label.show()

    btn = QPushButton(w)
    btn.setText('Beheld')
    btn.move(110,150)
    btn.show()
    btn.clicked.connect(dialog)

    
    w.show()
    sys.exit(app.exec_())

Enregistrez le fichier sous appone.py ou tout ce que vous voulez et appuyez sur F5 pour exécuter le programme. Si vous n'avez commis aucune erreur, le IDLE ouvrira une nouvelle fenêtre avec du texte et un bouton comme indiqué ci-dessous.

1. Une fois que vous avez cliqué sur le bouton dans la première fenêtre, une nouvelle boîte de message s'ouvrira avec le texte que vous avez écrit.
2. Vous pouvez maintenant cliquer sur le bouton Masquer les détails/Afficher les détails pour activer/désactiver la visibilité du texte supplémentaire.

Comme vous pouvez le voir, comme nous n'avions défini aucun titre de fenêtre dans la boîte de message, un titre par défaut a été fourni par python lui-même.

Maintenant que cela fonctionne, jetons un œil au code supplémentaire que vous avez ajouté à l'exemple PyQt5 précédent.

from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QMessageBox

Cela importe d'autres widgets que vous avez utilisés dans les exemples PyQt5, à savoir QLabel, QPushButton et QMessage.Box.

def dialog():
    mbox = QMessageBox()

    mbox.setText("Your allegiance has been noted")
    mbox.setDetailedText("You are now a disciple and subject of the all-knowing Guru")
    mbox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
            
    mbox.exec_()

Ici, vous avez défini une méthode nommée dialog qui crée un widget de boîte de message et définit du texte sur les boutons et autres champs.

La méthode de dialogue est appelée depuis le bloc principal du programme lorsqu'un bouton est enfoncé dans un widget spécifique (dans ce cas, le btn PushButton). L'événement click déclenché sur ce bouton provoque l'exécution de cette fonction. Une telle fonction s'appelle un slot dans Qt, et vous en apprendrez davantage sur signaux et le fentes dans les prochains paragraphes.

if __name__ == "__main__":
    app = QApplication(sys.argv)
    w = QWidget()
    w.resize(300,300)
    w.setWindowTitle("Guru99")

Il s'agit de la section principale de l'application et comme dans l'exemple précédent, vous commencez par créer une instance de QApplication suivie d'un simple widget, c'est à dire une instance de QWidget.

label = QLabel(w)
    btn = QPushButton(w)

Vous avez ajouté deux nouveaux widgets dans cette application : QLabel et QPushButton. QLabel est utilisé pour imprimer du texte non modifiable ou des espaces réservés à l'intérieur d'un widget, tandis que QPushButton est utilisé pour créer un bouton cliquable.

La chose essentielle à noter ici est que lorsque vous créez les objets label et btn, vous transmettez l'objet window (w) aux constructeurs de QLabel et QPushButton. C'est ainsi que fonctionne l'imbrication dans PyQt5. Pour créer un widget dans un autre widget, vous transmettez la référence du widget parent au constructeur de l'enfant.

label.move(100,130)
btn.move(110,150)

move() est utilisé pour définir la position d'un widget par rapport à son widget parent. Dans le premier cas, le label sera déplacé de 100px depuis la gauche et de 130px depuis le haut de la fenêtre.

De même, le bouton sera placé à 110px de la gauche et à 150px du haut de la fenêtre. Cet exemple est une manière rudimentaire de réaliser des mises en page et n'est généralement pas utilisé en production ; il n'est inclus ici qu'à des fins d'apprentissage. Qt prend en charge différentes mises en page que vous verrez en détail dans les prochaines sections de ce didacticiel PyQt.

btn.clicked.connect(dialog)

Enfin, voici un exemple de signaux et de slots dans Qt. Dans les applications basées sur une interface graphique, les fonctions sont exécutées en fonction des actions effectuées par l'utilisateur, comme survoler un élément ou cliquer sur un bouton. Ces actions sont appelées l'évènementiel. Rappelons que la méthode app.exec_() transfère le contrôle au Qt un événement-boucle. C'est à cela que sert la boucle d'événements : écouter les événements et effectuer des actions en réponse.

Chaque fois qu'un événement se produit, comme un utilisateur cliquant sur un bouton, le widget Qt correspondant déclenche un signal. Ces signaux peuvent être connectés à fonctions python (comme la fonction de dialogue dans cet exemple) afin que la fonction soit exécutée lorsqu'un signal est déclenché. Ces fonctions sont appelées fentes dans le jargon Qt.

Par la suite, la syntaxe de base pour déclencher une fonction slot en réponse au signal d'un événement est la suivante

 widget.signal.connect(slot)

Ce qui signifie que chaque fois qu'un signal est déclenché par un un widget, le connecté fente la fonction sera exécutée. En résumé, les signaux et les slots sont utilisés par Qt pour communiquer entre les objets et faciliter la réutilisabilité et l'interactivité des composants.

Maintenant que vous savez comment imbriquer des widgets et implémenter des interactions à l'aide de signaux et d'emplacements, voici une liste de widgets utiles et d'autres classes que vous pouvez utiliser dans vos applications PyQt.

Composants et widgets

Il existe un grand nombre de widgets disponibles dans PyQt pour créer des applications GUI. Cependant, avec PyQt5, il y a eu une redistribution des classes en différents modules et des révisions dans les licences.

Il est donc crucial d’avoir une vue d’ensemble de la structure de PyQt5. Dans cette section, vous verrez comment PyQt5 est organisé en interne et découvrirez les différents modules, bibliothèques et classes API fournis par PyQt5.

Structure du répertoire PyQt5

Ce sont les modules fondamentaux utilisés par Pythonla liaison Qt de , en particulier PyQt5.

• Qt: Il combine toutes les classes/modules mentionnés ci-dessous en un seul module. Cela augmente considérablement la mémoire utilisée par l’application. Cependant, il est plus facile de gérer le framework en important un seul module.
• QtCoreComment: Contient les classes non graphiques de base utilisées par d'autres modules. C'est là que la boucle d'événements Qt, les signaux et la connectivité des slots, etc. sont implémentés.
• QtWidgets: Contient la plupart des widgets disponibles dans Pyqt5.
• QtGuiName: Contient des composants GUI et étend le module QtCore.
• QtNetworkName: Contient les classes utilisées pour implémenter la programmation réseau via Qt. Il prend en charge les serveurs TCP, les sockets TCP, les sockets UDP, la gestion SSL, les sessions réseau et les recherches DNS.
• QtMultimédia fournit des fonctionnalités multimédia de bas niveau.
• QtSql: implémente l'intégration de bases de données pour les bases de données SQL. Prend en charge ODBC, MySQL, Oracle, SQLite et PostgreSQL.

Widgets PyQt5

Voici une liste des widgets les plus fréquemment utilisés dans PyQt5

• QLineModifier: Il s'agit d'un champ de saisie qui permet à l'utilisateur de saisir une ligne de texte.

  line = QLineEdit()

• QRadioButton: Il s'agit d'un champ de saisie avec un bouton sélectionnable, similaire aux boutons radio en HTML.

  rad = QRadioButton("button title")
  rad.setChecked(True)  #to select the button by default.

• QComboBox: Il permet d'afficher un menu déroulant avec une liste d'éléments sélectionnables.

  drop = QComboBox(w)
  drop.addItems(["item one", "item two", "item three"])

• QVérifiezBox: affiche une case carrée sélectionnable devant l'étiquette qui est cochée si elle est sélectionnée, semblable aux boutons radio.

  check = QCheckBox("button title")

• QBarre de Menu: il affiche une barre de menu horizontale en haut d'une fenêtre. Vous ne pouvez ajouter que des objets de la classe QMenu à cette barre. Ces objets QMenu peuvent en outre contenir des chaînes, des objets QAction ou d'autres objets QMenu.

• QToolBarComment: Il s'agit d'une barre ou d'un volet horizontal qui peut être déplacé dans la fenêtre. Il peut contenir des boutons et autres widgets.

• QTab: il est utilisé pour décomposer le contenu d'une fenêtre en plusieurs pages accessibles via différents onglets en haut du widget. Il se compose de deux sections : la barre d'onglets et la page à onglets.

• QScrollBar: Il est utilisé pour créer des barres de défilement qui permettent à l'utilisateur de faire défiler une fenêtre de haut en bas. Il se compose d'un curseur mobile, d'une piste de curseur et de deux boutons pour faire défiler le curseur vers le haut ou vers le bas.

  scroll = QScrollBar()

• QSplitter: Les séparateurs sont utilisés pour séparer le contenu d'une fenêtre afin que les widgets soient correctement regroupés et ne semblent pas encombrés. QSplitter est l'un des principaux gestionnaires de mise en page disponibles dans PyQt5 et est utilisé pour diviser le contenu horizontalement et verticalement.

• QDock: Un widget dock est une sous-fenêtre avec deux propriétés :
• Il peut être déplacé dans la fenêtre principale et
• Il peut être ancré en dehors de la fenêtre parent à un autre emplacement de l'écran.

Mises en page et thèmes

Dans les exemples PyQt5 précédents, vous avez uniquement utilisé les méthodes move() et resize() pour définir les positions des widgets dans votre interface graphique.

Cependant, PyQt dispose d'un moteur de gestion de mise en page robuste qui peut être utilisé pour créer des interfaces utilisateur avancées pour les applications. Dans cette section, vous découvrirez deux classes importantes utilisées dans Qt pour créer et gérer des mises en page.

1. QBoxMise En Page
2. QGridLayout

QBoxMise En Page

QBoxLa mise en page est utilisée pour aligner les widgets enfants de la mise en page sur une ligne horizontale ou verticale. Les deux classes d'intérêt qui héritent de QBoxLa mise en page est :

• QHBoxDisposition : utilisé pour aligner les widgets enfants horizontalement.
• QVBoxDisposition : utilisé pour aligner verticalement les widgets enfants.

Par exemple, voici comment trois boutons alignés avec QHBoxLa mise en page ressemblera.

import sys
from PyQt5.QtWidgets import *

if __name__ == "__main__":

    app = QApplication([])
    w = QWidget()
    w.setWindowTitle("Musketeers")

    btn1 = QPushButton("Athos")
    btn2 = QPushButton("Porthos")
    btn3 = QPushButton("Aramis")

    hbox = QHBoxLayout(w)

    hbox.addWidget(btn1)
    hbox.addWidget(btn2)
    hbox.addWidget(btn3)

    w.show()

    sys.exit(app.exec_())

Et voici à quoi ils ressembleront dans QVBoxDisposition.

import sys
from PyQt5.QtWidgets import *

if __name__ == "__main__":

    app = QApplication([])
    w = QWidget()
    w.setWindowTitle("Musketeers")

    btn1 = QPushButton("Athos")
    btn2 = QPushButton("Porthos")
    btn3 = QPushButton("Aramis")

    vb = QVBoxLayout(w)

    vb.addWidget(btn1)
    vb.addWidget(btn2)
    vb.addWidget(btn3)

    w.show()

    sys.exit(app.exec_())

La seule fonction qui nécessite une explication à ce stade est la méthode addWidget(). Il est utilisé pour insérer des widgets dans le HBox ou VBox mise en page. Il est également utilisé dans d'autres mises en page où il prend un nombre différent de paramètres, comme vous le verrez dans la section suivante. Les widgets apparaîtront à l'intérieur de la mise en page dans l'ordre dans lequel vous les insérez.

QGridLayout

QGridLayout est utilisé pour créer des interfaces dans lesquelles les widgets sont disposés sous la forme d'une grille (comme une matrice ou un tableau 2D). Pour insérer des éléments dans une disposition en grille, vous pouvez utiliser la représentation matricielle pour définir le nombre de lignes et de colonnes dans la grille ainsi que la position de ces éléments.

Par exemple, pour créer une grille 3*3 (c'est-à-dire une grille avec trois lignes et trois colonnes), vous écrirez le code suivant :

Import sys
from PyQt5.QtWidgets import *

if __name__ == "__main__":
    app = QApplication([])

    w = QWidget()

    grid = QGridLayout(w)

    for i in range(3):
        for j in range(3):
            grid.addWidget(QPushButton("Button"),i,j)


    w.show()
    sys.exit(app.exec_())

Ce sera la sortie :

La méthode addWidget() Dans la disposition en grille prend ces arguments :

• L'objet widget que vous souhaitez ajouter à la grille
• La coordonnée x de l'objet
• La coordonnée y de l'objet
• L'étendue des lignes (par défaut = 0)
• Le col-span (par défaut = 0)

Pour mieux le comprendre, vous pouvez insérer manuellement chaque widget comme indiqué ci-dessous

import sys
from PyQt5.QtWidgets import *

if __name__ == "__main__":
    app = QApplication([])

    w = QWidget()

    grid = QGridLayout(w)
    grid.addWidget(QPushButton("Button one"),0,0)
    grid.addWidget(QPushButton("Button two"),0,1)
    grid.addWidget(QPushButton("Button three"),1,0)
    grid.addWidget(QPushButton("Button four"),1,1)


    w.show()
    sys.exit(app.exec_())

Voici à quoi ressemblera la grille :

Vous pouvez également transmettre les paramètres rowspan et colspan à addWidget() afin de s'étendre sur plusieurs lignes ou colonnes.

Par exemple,

grid.addWidget(QPushButton("Button five"),2,0,1,0)

Cela créera un bouton qui s'étend sur les deux colonnes.

Themes

PyQt5 est livré avec des thèmes intégrés que vous pouvez utiliser dans vos applications. Le setStyle() La méthode appelée sur l’instance QApplication est utilisée pour définir un thème particulier pour votre application.

Par exemple, l'ajout de la ligne de code suivante modifiera le thème de votre application par défaut en Fusion.

app.setStyle("Fusion")

Voici à quoi ressemblera l’exemple précédent dans Fusion Theme

Une autre fonction utile pour thématiser vos applications est la méthode setPalette(). Voici le code pour changer la couleur des différents widgets à l'aide de setPalette().

import sys
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import *
from PyQt5.QtGui import QPalette

if __name__ == "__main__":
    app = QApplication([])
    app.setStyle("Fusion")
    
    qp = QPalette()
    qp.setColor(QPalette.ButtonText, Qt.black)
    qp.setColor(QPalette.Window, Qt.black)
    qp.setColor(QPalette.Button, Qt.gray)
    app.setPalette(qp)

    w = QWidget()

    grid = QGridLayout(w)
    grid.addWidget(QPushButton("Button one"),0,0)
    grid.addWidget(QPushButton("Button two"),0,1)
    grid.addWidget(QPushButton("Button three"),1,0)
    grid.addWidget(QPushButton("Button four"),1,1)


    w.show()
    sys.exit(app.exec_())

Voici le résultat.

Pour utiliser la méthode setPalette(), vous devez d'abord définir une palette. Cela se fait en créant un objet de la classe QPalette.

 qp = QPalette()

Notez que la classe QPalette appartient au module QtGui et vous devrez l'importer pour que cela fonctionne. Une fois que vous avez créé l'objet QPalette, utilisez la méthode setColor() pour transmettre le nom d'un widget dont vous souhaitez modifier la couleur et la couleur que vous souhaitez définir.

 qp.setColor(QPalette.Window, Qt.black)

Cela changera la couleur de la fenêtre en noir. Après avoir défini votre palette de couleurs, utilisez la fonction setPalette() pour appliquer la palette à votre application.

app.setPalette(qp)

C'est tout ce que vous devez faire si vous souhaitez créer des thèmes de base pour votre application. PyQt vous permet également d'utiliser des feuilles de style pour définir l'apparence de vos widgets. Si vous êtes familier avec CSS, vous pouvez facilement définir des styles avancés pour votre application à l'aide des feuilles de style Qt.

Résumé

• PyQt est la liaison Python pour le C++ Cadre d'interface utilisateur, Qt.
• PyQt4 et PyQt5 sont les deux versions majeures développées par Riverbank Computing.
• Les principaux modules du framework PyQt sont :
1. Qt
2. QtCoreComment
3. QtWidgets
4. QtGuiName
5. QtSql
6. QtNetworkName
• PyQt prend en charge divers widgets tels que :
1. Boutons
2. Étiquettes de texte
3. Champs de texte
4. Boutons radio et cases à cocher
5. Barres d'outils et barres de menus
6. Kit Web
7. Tabs
8. Docks
• Dans PyQt, l'interactivité est implémentée à l'aide signaux et le fentes.
• An event est une action effectuée par un utilisateur dans l'interface graphique (comme cliquer sur un bouton).
• A signal est déclenché par le widget correspondant lorsqu'un événement se produit sur celui-ci.
• A fente est une fonction qui est connectée au signal et s'exécute lorsque le signal est élevé.
• PyQt dispose d'un moteur de mise en page robuste et prend en charge la conception et la gestion avancées de la mise en page. Voici deux schémas de mise en page fréquemment utilisés dans PyQt :
1. Box Mise En Page
2. Disposition de la grille
• Le concepteur PyQt vous permet de créer des thèmes personnalisés pour les applications GUI et prend en charge les feuilles de style.
• créateur Qt Python peut être utilisé pour créer des interfaces utilisateur ainsi que des applications autonomes.