Programmation serveur Python : développer des programmes GUI à l'aide de PySide2

Python est devenu un langage de programmation très populaire, de nombreux développeurs profitant de la simplicité et de la flexibilité de Python pour créer une variété d'applications. Parmi ceux-ci, Python est également utilisé pour développer des applications côté serveur, et PySide2 est l'un des outils les plus importants dans ce processus.

PySide2 est une liaison pour le langage de programmation Python pour le framework Qt. Cet outil permet aux programmeurs Python d'écrire des programmes qui utilisent des structures GUI. PySide2 étant un outil multiplateforme qui s'exécute sur tous les principaux systèmes d'exploitation, il est particulièrement adapté au développement de programmes côté serveur.

Dans cet article, nous verrons comment développer des programmes GUI à l'aide de la programmation serveur PySide2 et Python. Nous commencerons par des applications PySide2 simples, montrerons comment leur ajouter des fonctionnalités et des gestionnaires d'événements, et discuterons de la façon de créer des programmes GUI avec des fonctionnalités complexes telles que des contrôles et des animations d'interface utilisateur.

1. Installez PySide2

Tout d'abord, nous devons installer PySide2. PySide2 fonctionne sur différents systèmes d'exploitation, alors installez-le en conséquence en fonction de votre système d'exploitation.

Sous Linux, nous pouvons installer PySide2 via pip en utilisant la commande suivante :

pip install PySide2

Sur les systèmes Windows, nous pouvons utiliser la même commande dans l'invite de commande pour installer PySide2.

Une fois l'installation terminée, nous pouvons commencer à écrire notre première application PySide2.

2. Développer une application PySide2 simple

Nous commencerons par une application PySide2 très simple qui crée uniquement une fenêtre et un onglet. Afin de créer cette application, nous devons importer les modules PySide2.QtWidgets et sys :

import sys
from PySide2.QtWidgets import QApplication, QLabel, QWidget

Ensuite, nous devons créer un objet QApplication et QWidget. Nous utiliserons des objets QWidget pour créer notre interface graphique :

app = QApplication(sys.argv)

widget = QWidget()
widget.setWindowTitle('My First PySide2 Application')
widget.setGeometry(300, 300, 250, 150)

label = QLabel('Hello World', widget)
label.move(100, 50)

widget.show()

sys.exit(app.exec_())

Cet extrait de code créera un objet QWidget et définira sa position et sa taille. Il créera également une étiquette et l'ajoutera à l'objet QWidget. Les étiquettes sont créées à l'aide de la classe QLabel. Enfin, nous utilisons la méthode show pour afficher l'interface graphique et quitter l'application.

3. Ajouter des gestionnaires d'événements à l'application

Maintenant, nous avons créé une simple application PySide2, mais elle ne peut encore rien faire. Pour que notre application réagisse aux événements, nous devons ajouter des gestionnaires d'événements.

Dans PySide2, nous pouvons utiliser des slots pour définir des gestionnaires d'événements. Les slots sont une méthode pour recevoir des événements GUI et les gérer. Dans cet exemple, nous allons créer une nouvelle classe qui héritera de QWidget et définira une méthode slot.

L'extrait de code ci-dessous créera un bouton et l'ajoutera à un objet QWidget. Ce bouton déclenchera l'événement PushButtonClicked. Cet événement sera déclenché chaque fois que le bouton sera cliqué. Nous allons définir une méthode slot dans notre application qui gérera l'événement PushButtonClicked et affichera un message sur la console :

import sys
from PySide2.QtCore import Slot
from PySide2.QtWidgets import QApplication, QPushButton, QWidget

class MyWidget(QWidget):

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

        self.initUI()

    def initUI(self):

        button = QPushButton('Click me', self)
        button.setToolTip('Click this button')
        button.move(100, 70)

        button.clicked.connect(self.on_pushButton_clicked)

        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('My Second PySide2 Application')
        self.show()

    @Slot()
    def on_pushButton_clicked(self):
        print('Button clicked.')

Désormais, lorsque nous cliquons sur le bouton, le programme affichera "Bouton cliqué" sur les informations de la console. Notez que le décorateur @Slot() est utilisé devant la méthode. Cela indique au programme que cette méthode est un slot PySide2 à appeler.

4. Créez un programme GUI avec des contrôles et des animations d'interface utilisateur

Nous pouvons maintenant créer une application PySide2 simple avec des boutons et des gestionnaires d'événements. Ensuite, ajoutons plus de contrôles et d'animations au programme.

Dans cet exemple, nous allons créer une nouvelle classe, qui héritera de la classe QDialog. QDialog est une classe de PySide2 utilisée pour afficher des boîtes de dialogue. Dans ce cours, nous allons créer une nouvelle balise pour le tournesol afin de suivre la source de lumière et utiliser le cadre d'animation de PySide2 pour créer un petit soleil. Nous ajouterons également un bouton pour contrôler le mouvement du soleil.

import sys
from PySide2.QtCore import QPropertyAnimation, QRect
from PySide2.QtGui import QPainter, QColor
from PySide2.QtWidgets import QApplication, QDialog, QLabel, QPushButton
from PySide2 import QtGui

class Sun(QWidget):
    def __init__(self):
        super().__init__()

        self.initUI()

    def initUI(self):
        self.setFixedSize(100, 100)
        self.color = QColor(255, 255, 0)

    def paintEvent(self, event):
        painter = QPainter(self)
        painter.setBrush(QtGui.QBrush(self.color))
        painter.drawEllipse(0, 0, self.width(), self.height())

class FollowSunDialog(QDialog):
    def __init__(self):
        super().__init__()

        self.initUI()

    def initUI(self):
        self.setWindowTitle('Follow the Sun')
        self.setGeometry(100, 100, 400, 400)

        sun_label = QLabel(self)
        sun_label.setFixedSize(50, 50)
        pixmap = QtGui.QPixmap('sun.png')
        sun_label.setPixmap(pixmap)

        self.sun = Sun()
        self.sun.move(50, 150)

        self.button = QPushButton('Start', self)
        self.button.move(50, 300)
        self.button.clicked.connect(self.onClick)

    def onClick(self):
        animator = QPropertyAnimation(self.sun, b'geometry')
        animator.setDuration(3000)
        animator.setStartValue(QRect(50, 150, 100, 100))
        animator.setEndValue(QRect(200, 50, 50, 50))

        animator.start()

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

    dialog = FollowSunDialog()
    dialog.show()

    sys.exit(app.exec_())

Dans cet extrait de code, nous définissons deux classes, la classe Sun et la classe FollowSunDialog. La classe Sun est une sous-classe de QWidget et est utilisée pour dessiner des images du soleil. La classe FollowSunDialog est une sous-classe de QDialog et est utilisée pour afficher des boîtes de dialogue et contrôler le mouvement du soleil.

Nous avons également ajouté une image du soleil pour dessiner le petit soleil, qui est un fichier sun.png stocké dans le même répertoire que les fichiers du programme. Nous avons créé un QPushButton qui, une fois enfoncé, lancera l'animation du widget soleil se déplaçant vers le coin supérieur droit.

Les animations sont créées à l'aide du framework d'animation PySide2. Lorsque le bouton est enfoncé, nous définissons un objet QPropertyAnimation qui utilise les propriétés startValue et endValue pour définir les positions de début et de fin du widget soleil. Il définit également le timing de l'animation.

Conclusion :

Cet article présente la combinaison de la programmation serveur PySide2 et Python. Nous avons créé une application PySide2 simple, ajouté des gestionnaires d'événements à l'application et créé un programme GUI avec des contrôles et des animations d'interface utilisateur. PySide2 est un outil très puissant pour créer des applications Python avec une structure GUI. Pour les développeurs côté serveur, PySide2 peut réduire le temps de développement et augmenter l'interactivité et la facilité d'utilisation des applications.

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!