Démarrer avec pyqt5

Hello World Exemple

Cet exemple crée une fenêtre simple avec un bouton et une modification de ligne dans une mise en page. Il montre également comment connecter un signal à un slot, de sorte que cliquer sur le bouton ajoute du texte à la ligne d’édition.

import sys
from PyQt5.QtWidgets import QApplication, QWidget


if __name__ == '__main__':
    
    app = QApplication(sys.argv)

    w = QWidget()
    w.resize(250, 150)
    w.move(300, 300)
    w.setWindowTitle('Hello World')
    w.show()
    
    sys.exit(app.exec_())

Une analyse

app = QtWidgets.QApplication(sys.argv)

Chaque application PyQt5 doit créer un objet d’application. Le paramètre sys.argv est une liste d’arguments d’une ligne de commande. Les scripts Python peuvent être exécutés à partir du shell.

w = QWidget()

Le widget QWidget est la classe de base de tous les objets d’interface utilisateur dans PyQt5. Nous fournissons le constructeur par défaut pour QWidget. Le constructeur par défaut n’a pas de parent. Un widget sans parent est appelé une fenêtre.

w.resize(250, 150)

La méthode resize() redimensionne le widget. Il fait 250px de large et 150px de haut.

w.move(300, 300)

La méthode move() déplace le widget vers une position sur l’écran aux coordonnées x=300, y=300.

w.setWindowTitle('Hello World')

Ici, nous définissons le titre de notre fenêtre. Le titre est affiché dans la barre de titre.

w.show()

La méthode show() affiche le widget à l’écran. Un widget est d’abord créé en mémoire et ensuite affiché à l’écran.

sys.exit(app.exec_())

Enfin, nous entrons dans la boucle principale de l’application. La gestion des événements commence à partir de ce point. La boucle principale reçoit les événements du système de fenêtres et les distribue aux widgets de l’application. La boucle principale se termine si nous appelons la méthode exit() ou si le widget principal est détruit. La méthode sys.exit() assure une sortie propre. L’environnement sera informé de la fin de l’application.

La méthode exec_() a un trait de soulignement. C’est parce que exec est un mot-clé Python. Et donc, exec_() a été utilisé à la place.

Ajout d’une icône d’application

import sys
from PyQt5.QtWidgets import QApplication, QWidget
from PyQt5.QtGui import QIcon


class Example(QWidget):
    
    def __init__(self):
        super().__init__()
        
        self.initUI()
        
        
    def initUI(self):
        
        self.setGeometry(300, 300, 300, 220)
        self.setWindowTitle('Icon')
        self.setWindowIcon(QIcon('web.png'))        
    
        self.show()
        
        
if __name__ == '__main__':
    
    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_()) 

Une analyse

*** Arguments de fonction en Python ***

En Python, les fonctions définies par l’utilisateur peuvent prendre quatre types d’arguments différents.

  1. Arguments par défaut :
  • Définition de la fonction

def defaultArg( nom, msg = "Bonjour!"):

  • Appel de fonction

    defaultArg( name)

  1. Arguments requis :
  • Définition de la fonction

    def requiredArg (str,num):

  • Appel de fonction :

    requiredArg ("Hello",12)

  1. Arguments des mots clés :
  • Définition de la fonction

    def keywordArg( name, role ):

  • Appel de fonction

    keywordArg( name = "Tom", role = "Manager")

    or

    keywordArg( role = "Manager", name = "Tom")

  1. Nombre variable d’arguments :
  • Définition de la fonction

    def varlengthArgs(*varargs):

  • Appel de fonction

    varlengthArgs(30,40,50,60)

    class Example(QWidget):

      def __init__(self):
          super().__init__()
          ...
    

Trois choses importantes dans la programmation orientée objet sont les classes, les données et les méthodes. Ici, nous créons une nouvelle classe appelée Example. La classe Example hérite de la classe QWidget. Cela signifie que nous appelons deux constructeurs : le premier pour la classe Example et le second pour la classe héritée. La méthode super() renvoie l’objet parent de la classe Example et nous appelons son constructeur. La variable self fait référence à l’objet lui-même.

Pourquoi avons-nous utilisé __init__ ?

Regarde ça:

class A(object):
    def __init__(self):
        self.lst = []

class B(object):
    lst = []

et maintenant essayez:

>>> x = B()
>>> y = B()
>>> x.lst.append(1)
>>> y.lst.append(2)
>>> x.lst
[1, 2]
>>> x.lst is y.lst
True

et ça:

>>> x = A()
>>> y = A()
>>> x.lst.append(1)
>>> y.lst.append(2)
>>> x.lst
[1]
>>> x.lst is y.lst
False

Cela signifie-t-il que x dans la classe B est établi avant l’instanciation ?

Oui, c’est un attribut de classe (il est partagé entre les instances). Alors que dans la classe A, c’est un attribut d’instance.

self.initUI() 

La création de l’interface graphique est déléguée à la méthode initUI().

self.setGeometry(300, 300, 300, 220)
self.setWindowTitle('Icon')
self.setWindowIcon(QIcon('web.png'))  

Les trois méthodes ont été héritées de la classe QWidget. Le setGeometry() fait deux choses : il localise la fenêtre sur l’écran et définit sa taille. Les deux premiers paramètres sont les positions x et y de la fenêtre. Le troisième est la largeur et le quatrième est la hauteur de la fenêtre. En fait, il combine les méthodes resize() et move() en une seule méthode. La dernière méthode définit l’icône de l’application. Pour ce faire, nous avons créé un objet QIcon. Le QIcon reçoit le chemin vers notre icône à afficher.

if __name__ == '__main__':
    
    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

L’application et les exemples d’objets sont créés. La boucle principale est démarrée.

Affichage d’une info-bulle

import sys
from PyQt5.QtWidgets import (QWidget, QToolTip, 
    QPushButton, QApplication)
from PyQt5.QtGui import QFont    


class Example(QWidget):
    
    def __init__(self):
        super().__init__()
        
        self.initUI()
        
        
    def initUI(self):
        
        QToolTip.setFont(QFont('SansSerif', 10))
        
        self.setToolTip('This is a <b>QWidget</b> widget')
        
        btn = QPushButton('Button', self)
        btn.setToolTip('This is a <b>QPushButton</b> widget')
        btn.resize(btn.sizeHint())
        btn.move(50, 50)       
        
        self.setGeometry(300, 300, 300, 200)
        self.setWindowTitle('Tooltips')    
        self.show()
        
        
if __name__ == '__main__':
    
    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

Une analyse

QToolTip.setFont(QFont('SansSerif', 10))

Cette méthode statique définit une police utilisée pour afficher les info-bulles. Nous utilisons une police SansSerif 10px.

self.setToolTip('This is a <b>QWidget</b> widget')

Pour créer une info-bulle, nous appelons la méthode setTooltip(). Nous pouvons utiliser la mise en forme de texte enrichi.

btn = QPushButton('Button', self)
btn.setToolTip('This is a <b>QPushButton</b> widget')

Nous créons un widget de bouton-poussoir et définissons une info-bulle pour celui-ci.

btn.resize(btn.sizeHint())
btn.move(50, 50) 

Le bouton est redimensionné et déplacé sur la fenêtre. La méthode sizeHint() donne une taille recommandée pour le bouton.

Empaquetez votre projet dans un fichier exécutable/installateur

cx_Freeze - un outil peut empaqueter votre projet en exécutable/installateur

  • après l’avoir installé par pip, pour empaqueter demo.py, nous avons besoin de setup.py ci-dessous.
import sys
from cx_Freeze import setup, Executable

# Dependencies are automatically detected, but it might need fine tuning.
build_exe_options = {
    "excludes": ["tkinter"],
    "include_files":[('./platforms','./platforms')] # need qwindows.dll for qt5 application
}

# GUI applications require a different base on Windows (the default is for a
# console application).
base = None
if sys.platform == "win32":
    base = "Win32GUI"

setup(  name = "demo",
        version = "0.1",
        description = "demo",
        options = {"build_exe": build_exe_options},
        executables = [Executable("demo.py", base=base)])
  • puis construire
python .\setup.py build
  • puis dist
python .\setup.py bdist_msi

Installation ou configuration

  1. Installez Anaconda (PyQt5 est intégré), en particulier pour les utilisateurs Windows. [![][1]][1]
  2. Intégrez QtDesigner et QtUIConvert dans PyCharm (Outils externes)
    • Open PyCharm Settings > Tools > External Tools
    • Create Tool(QtDesigner) - used to edit *.ui files [![][2]][2]
    • Create Tool(PyUIConv) - used to convert *.ui to *.py [![][3]][3]
  3. Rédigez une démo
    • new window.ui by external tool(QtDesigner) [![][4]][4]
    • convert to window.py by external tool(PyUIConv) [![][5]][5]
    • demo [![][6]][6]
      import sys
      from PyQt5.QtWidgets import QApplication,QMainWindow
      from window import Ui_MainWindow
      
      if __name__ == '__main__':
          app = QApplication(sys.argv)
          w = QMainWindow()
          ui = Ui_MainWindow()
          ui.setupUi(w)
          w.show()
          sys.exit(app.exec_())
      

[1] : https://i.stack.imgur.com/oY4gz.png [2] : https://i.stack.imgur.com/ESdG6.png [3] : https://i.stack.imgur.com/3oImy.png [4] : https://i.stack.imgur.com/k1CBb.png [5] : https://i.stack.imgur.com/em0LZ.png [6] : https://i.stack.imgur.com/wbe8n.png