Tutoriel PyQt5 avec exemples : Créer Python Interfaces graphiques avec Qt

Les sections ci-dessous vous guideront depuis les bases de PyQt jusqu'à l'installation, les widgets principaux, les mises en page et les thèmes, avec des exemples exécutables.

Qu'est-ce que PyQt ?

PyQtName est une Python Qt est une bibliothèque intégrée du kit d'outils open source de widgets Qt, qui sert également de framework de développement d'applications multiplateformes. Qt est un outil populaire. C++ framework pour l'écriture d'applications GUI pour toutes les principales plateformes de bureau, mobiles et embarquées (il prend en charge Linux, Windows, macOS, Android, iOS, Raspberry Pi, et plus).

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 entreprise finlandaise appelée The Qt Company.

Caractéristiques de PyQt

Voici les fonctionnalités importantes de PyQt :

PyQt comprend plus de six cents classes couvrant un large éventail 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 les secteurs utilisent Qt. Citons par exemple LG, Mercedes, AMD, Panasonic et Harman.

Versions PyQt

PyQt est disponible en deux versions : PyQt4 et PyQt5. PyQt4 assure l’interface entre les versions 4.x et 5.x du framework Qt, tandis que PyQt5 ne prend en charge que les versions 5.x. Par conséquent, PyQt5 n’est pas compatible avec les modules obsolètes des versions précédentes. Dans ce tutoriel sur l’interface graphique PyQt, PyQt5 sera utilisé pour les exemples. Outre ces deux versions, Riverbank Computing propose également PyQt3D. Python Liaisons pour le framework Qt3D. Qt3D est un framework applicatif utilisé pour créer des systèmes de simulation en temps réel avec 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 Python le code sous-jacent. Par conséquent, sa compilation et son installation à partir du code source sont un processus complexe comparé à d'autres logiciels. Python bibliothèques. Cependant, vous pouvez facilement installer PyQt5 à l'aide de roues.

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 PythonVous devez télécharger et installer pip avant de continuer. Vous trouverez des instructions à 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é 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é PyQt5 avec succès sur votre ordinateur, vous êtes prêt à écrire. Python Applications GUI.

Commençons ce tutoriel PyQt5 par une application simple 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 le nom app.py (le nom n'a pas d'importance) et appuyez sur F5 pour exécuter le programme. Vous pouvez également double-cliquer sur le 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 fonctionne. Ce n'est pas grand-chose, mais c'est suffisant pour comprendre les bases. Dans ce tutoriel PyQt, nous allons maintenant examiner en détail le rôle de chaque ligne 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, aucun argument n'a été passé à QApplication. Vous pouvez donc 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.

Il est important de rappeler ici que les widgets peuvent être imbriqués les uns dans les autres ; 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 de caractères en argument, ce qui définira le titre de la fenêtre avec cette chaîne. 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_()` transmet 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 cas. Python programmes. Étant donné que Qt contrôle l'application, Python Les événements ne sont traités que si nous les configurons dans l'application. Notez également que la méthode `exec` contient un trait de soulignement ; cela s'explique par le fait que `exec()` était déjà un mot-clé dans… Python et le trait de soulignement résout le conflit de dénomination.

Au-delà des fenêtres vides

Dans la section précédente, vous avez vu comment créer un widget basique avec Qt. Il est maintenant temps de créer des interfaces plus complexes avec lesquelles les utilisateurs pourront interagir. Lancez à nouveau votre application Qt. 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 le nom appone.py ou tout autre nom de votre choix et appuyez sur F5 pour exécuter le programme. Si vous n'avez commis aucune erreur, 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 constater, comme nous n'avions pas défini de titre de fenêtre dans la boîte de message, un titre par défaut a été fourni par Python elle-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 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 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 widget simple, 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 à 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 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 déclenche un signal. Ces signaux peuvent être connectés à Python fonctions (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 conséquent, la syntaxe de base pour déclencher une fonction de slot en réponse au signal d'un événement est la suivante :

 widget.signal.connect(slot)

Cela 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 essentiel d'avoir une vue d'ensemble de la structure de PyQt5. Dans cette section, vous découvrirez l'organisation interne de PyQt5 ainsi que les différents modules, bibliothèques et classes d'API qu'il propose.

Structure du répertoire PyQt5

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

• QtCe module regroupe toutes les classes et tous les modules mentionnés ci-dessous en un seul. Il augmente considérablement la mémoire utilisée par l'application. Cependant, l'importation d'un seul module simplifie la gestion du framework.
• 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.
• QtWidgetsContient 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: offre des fonctionnalités multimédias 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 MenuElle affiche une barre de menu horizontale en haut de la fenêtre. Seuls les objets de la classe QMenu peuvent y être ajoutés. Ces objets QMenu peuvent contenir des chaînes de caractères, 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.
• QTabIl permet de diviser le contenu d'une fenêtre en plusieurs pages accessibles via différents onglets situés en haut du widget. Il se compose de deux parties : la barre d'onglets et la page d'onglets.
• QScrollBarIl sert à créer des barres de défilement permettant à l'utilisateur de faire défiler une fenêtre verticalement. Il se compose d'un curseur mobile et d'un curseur. track, et 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.
• QDockUn widget d'ancrage est une sous-fenêtre possédant deux propriétés : elle peut être déplacée à l'intérieur de la fenêtre principale et elle peut être ancrée à l'extérieur de la fenêtre parente, à un autre emplacement sur 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() de la mise en page en grille prend les arguments suivants :

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

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

Thèmes

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, en le faisant passer du thème par défaut au thème Fusion.

app.setStyle("Fusion")

Voici à quoi ressemblera l'exemple précédent dans le thème Fusion.

Une autre fonction utile pour personnaliser l'apparence de vos applications est la méthode `setPalette()`. Voici le code permettant de modifier 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 que vous devrez l'importer pour que cela fonctionne. Une fois l'objet QPalette créé, utilisez la méthode setColor() en lui passant le nom du widget dont vous souhaitez modifier la couleur et la couleur à appliquer.

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

Cela changera la couleur de la fenêtre en noir. Une fois votre palette de couleurs définie, utilisez la fonction setPalette() pour l'appliquer à 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.

FAQ