home Technologie de fabrication Équipement de fabrication
Fabrication industrielle
Internet des objets industriel | Matériaux industriels | Entretien et réparation d'équipement | Programmation industrielle |
home  MfgRobots >> Fabrication industrielle >  >> Industrial programming >> Python

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

Qu'est-ce que PyQt ?

PyQt est une liaison python du widget-toolkit open source Qt, qui fonctionne également comme un framework de développement d'applications multiplateforme. Qt est un framework C++ populaire pour l'écriture d'applications graphiques pour toutes les principales plates-formes de bureau, mobiles et embarquées (prend en charge Linux, Windows, MacOS, Android, iOS, Raspberry Pi, etc.).

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.

Dans ce tutoriel PyQt5, vous apprendrez :

Fonctionnalités de PyQT

Voici les fonctionnalités importantes de PyQt :

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

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 les secteurs utilisent Qt. Quelques exemples sont LG, Mercedes, AMD, Panasonic, Harman, etc.

Versions de PyQt

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

Riverbank Computing fournit également PyQt3D, les liaisons Python pour le framework Qt3D. Qt3D est un cadre 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 :

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

Installation avec roues

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

Donc, si vous avez installé Python 3.4 ou une version ultérieure, vous avez déjà pip. Si, toutefois, vous utilisez une ancienne version de Python, vous devez télécharger et installer pip avant de continuer. Vous pouvez rechercher des instructions pour cela 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 sur votre ordinateur Windows.

É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 binaire Windows 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 graphique.

Concepts et programmes de base de PyQt

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

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

Lancez votre python IDLE et tapez 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. Alternativement, double-cliquez 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 tutoriel 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 tutoriel Python 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 et même ne pas 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 d'interface utilisateur dans 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 à l'intérieur d'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 à 300px par 300px.

Ici, vous devez vous rappeler que les widgets peuvent être imbriqués ensemble, le widget le plus à l'extérieur (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 passez. 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 la boucle d'événements Qt/C++. 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 ne quittera l'application que 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 contrôle l'application, les événements python ne sont pas traités à moins que nous ne les configurions dans 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 le trait de soulignement résout le conflit de nom.

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 impliquées avec lesquelles les utilisateurs peuvent vraiment interagir. Encore une fois, lancez votre IDLE et écrivez 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, l'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 basculer la visibilité du texte supplémentaire.

Comme vous pouvez le voir, puisque 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, examinons le 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 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_()

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 d'autres champs.

La méthode dialog est appelée depuis le bloc principal du programme lorsqu'un bouton est pressé dans un widget spécifique (dans ce cas, le btn PushButton). L'événement de clic 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 plus sur les signaux et emplacements 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 à remarquer ici est que lorsque vous créez les objets label et btn, vous passez l'objet window (w) aux constructeurs de QLabel et QPushButton. C'est ainsi que fonctionne l'imbrication dans PyQt5. Pour créer un widget à l'intérieur d'un autre widget, vous passez 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, l'étiquette sera déplacée de 100px de la gauche et de 130px du 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 grossière 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 tutoriel PyQt.

btn.clicked.connect(dialog)

Enfin, voici un exemple de signaux et de slots dans Qt. Dans les applications basées sur l'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 événements . Rappelez-vous que la méthode app.exec_() transfère le contrôle au Qt event- 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 lève un signal . Ces signaux peuvent être connectés à des 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 slots 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 widget , l'emplacement connecté 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éutilisation 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 un remaniement des classes dans différents modules et révisions dans les licences.

Par conséquent, il est 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 d'API fournis par PyQt5.

Structure du répertoire PyQt5

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

Widgets PyQt5

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

Mises en page et thèmes

Dans les exemples PyQt5 précédents, vous n'avez utilisé que 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. QBoxLayout
  2. QGridLayout

QBoxLayout

QBoxLayout est utilisé 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 QBoxLayout sont :

Par exemple, voici à quoi ressembleront trois boutons alignés avec QHBoxLayout.

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 QVBoxLayout.

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 la mise en page HBox ou VBox. Il est également utilisé dans d'autres dispositions 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 de 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 allez écrire 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_())

Voici le résultat :

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

Pour mieux 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 passer les paramètres rowspan et colspan à addWidget() afin de couvrir plusieurs lignes ou colonnes.

Par exemple,

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

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

Thèmes

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

Par exemple, l'ajout de la ligne de code suivante changera 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 de 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é


Python

  • Langue C
  • VHDL
  • Verilog
  • MATLAB
  • Python
  • Java

    1. Python String count() avec des EXEMPLES
    2. Python String format() Expliquer avec des EXEMPLES
    3. Méthode Python String find() avec exemples
    4. Fonctions Python Lambda avec EXEMPLES
    5. Fonction Python round() avec EXEMPLES
    6. Fonction Python map() avec EXEMPLES
    7. Python Timeit() avec des exemples
    8. Compteur Python dans les collections avec exemple
    9. type() et isinstance() en Python avec des exemples