Découvrez comment créer votre première fenêtre avec PyQt6
Un guide complet pour débuter avec PyQt6 en Python
Points Clés de la Création d'une Fenêtre PyQt6
- Configuration initiale et installation : Installation via pip et configuration de l'environnement.
- Structure de base : Utilisation de QWidget ou QMainWindow pour créer et afficher la fenêtre.
- Extension et interaction : Ajout de widgets, mise en place des layouts et gestion des événements.
Introduction et Installation de PyQt6
Pour créer une fenêtre en Python avec PyQt6, la première étape consiste à installer la bibliothèque. Ouvrez votre terminal et exécutez la commande suivante :
pip install PyQt6Cette commande installe PyQt6 et vous permet de bénéficier de toutes les fonctionnalités pour créer des interfaces graphiques.
Création d’une Fenêtre Simple avec PyQt6
Le concept de base consiste à créer une instance de QApplication et de définir une fenêtre en utilisant un widget de base comme QWidget. Voici un exemple simple illustrant ce processus :
Exemple de fenêtre simple
import sys
from PyQt6.QtWidgets import QApplication, QWidget
# Création de l'application
app = QApplication(sys.argv)
# Création de la fenêtre de base avec QWidget
window = QWidget()
window.setWindowTitle("Ma première fenêtre PyQt6")
window.setGeometry(100, 100, 400, 300) # Position (x, y) et dimensions (largeur, hauteur)
window.show() # Affichage de la fenêtre
# Démarrage de la boucle d'événements
sys.exit(app.exec())
Dans cet exemple, le module sys est utilisé pour gérer la sortie de l’application et QApplication initialise l'application. Le widget de base QWidget permet de créer et de configurer la fenêtre en définissant le titre et la géométrie. Enfin, show() affiche la fenêtre et la boucle d'événements est démarrée avec app.exec().
Création d'une Fenêtre Plus Complexe et Ajout de Widgets
Pour créer une application graphique plus avancée, vous pouvez hériter de QMainWindow afin de bénéficier d'une structure avec barre de menus, barre d'outils et autres composants. Vous pouvez également intégrer différents widgets comme des boutons, des labels, et organiser ces éléments avec des layouts adaptés.
Exemple avec QMainWindow et Widgets
import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QVBoxLayout, QWidget
class MainWindow(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Ma fenêtre PyQt6 avec Widgets")
self.setGeometry(100, 100, 600, 400)
# Création d'un widget central et d'un layout
central_widget = QWidget(self)
self.setCentralWidget(central_widget)
layout = QVBoxLayout()
# Ajout d'un label pour afficher un message
self.label = QLabel("Bonjour, cliquez sur le bouton !", self)
layout.addWidget(self.label)
# Ajout d'un bouton et connexion à une fonction événementielle
self.button = QPushButton("Cliquez ici", self)
self.button.clicked.connect(self.on_button_click)
layout.addWidget(self.button)
central_widget.setLayout(layout)
def on_button_click(self):
self.label.setText("Vous avez cliqué sur le bouton !")
if __name__ == "__main__":
app = QApplication(sys.argv)
main_window = MainWindow()
main_window.show()
sys.exit(app.exec())
Ici, nous utilisons QMainWindow pour une structure plus riche et un widget central auquel est appliqué un layout vertical (QVBoxLayout).
Le label affiche un message, et lorsque le bouton est cliqué, le texte du label est modifié grâce à un slot connecté à l'action du bouton.
Gestion des Événements et Multiples Fenêtres
La gestion des événements est centrale dans la création d'interfaces graphiques interactives. PyQt6 permet de connecter des signaux (événements) à des slots (fonctions ou méthodes). Par exemple, on peut créer plusieurs fenêtres dans une même application. Le code ci-dessous montre comment ouvrir une nouvelle fenêtre en cliquant sur un bouton :
Exemple pour ouvrir une seconde fenêtre
import sys
from PyQt6.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout
class AutreFenetre(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Autre Fenêtre")
self.setGeometry(200, 200, 300, 200)
class FenetrePrincipale(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("Fenêtre Principale")
self.setGeometry(100, 100, 400, 300)
layout = QVBoxLayout()
bouton = QPushButton("Ouvrir Autre Fenêtre", self)
bouton.clicked.connect(self.ouvrir_autre_fenetre)
layout.addWidget(bouton)
self.setLayout(layout)
self.autre_fenetre = None
def ouvrir_autre_fenetre(self):
if self.autre_fenetre is None:
self.autre_fenetre = AutreFenetre()
self.autre_fenetre.show()
if __name__ == "__main__":
app = QApplication(sys.argv)
fenetre = FenetrePrincipale()
fenetre.show()
sys.exit(app.exec())
Dans cet exemple, la classe FenetrePrincipale ouvre une autre fenêtre (instance de AutreFenetre) lorsque l'utilisateur clique sur le bouton. Il est crucial de conserver une référence à cette nouvelle fenêtre afin d'éviter que le ramasse-miettes de Python ne la détruise.
Visualisation des Composants et de la Structure
Pour mieux visualiser l'interconnexion entre les différents composants d'une application PyQt6, nous vous proposons ce diagramme mental qui regroupe les principaux éléments:
Ce schéma simplifié vous aide à comprendre la relation entre une application (QApplication), le widget principal (QWidget ou QMainWindow), les widgets additionnels, les layouts servant à l'organisation et la gestion des événements.
Analyse de Performances et Composants via Radar Chart
Le diagramme suivant, sous forme de radar chart, résume l'importance relative des divers aspects dans le développement d'interfaces graphiques avec PyQt6. Ce graphique met en avant : l'installation, la structure de base, la gestion des événements, l'ajout de widgets et la modularité à travers la création de multiples fenêtres.
Comparaison des Concepts Clés
Pour vous aider à visualiser et à comparer les différentes approches pour créer une interface graphique simple, voici un tableau récapitulatif des points abordés :
| Aspect | Description | Exemple de Code |
|---|---|---|
| Fenêtre Simple | Utilisation de QWidget pour créer une fenêtre de base avec un titre et une géométrie définie. |
|
| Fenêtre Complexe | Utilisation de QMainWindow et ajout d'un widget central, de layouts et de widgets interactifs. |
|
| Gestion d'Événements | Connexion des signaux (comme les clics de bouton) à des slots pour réagir aux actions de l'utilisateur. |
|
| Multiples Fenêtres | Création et affichage de plusieurs fenêtres dans une même application pour une interface modulaire. |
|
Vidéo Tutoriel Recommandée
Pour approfondir vos connaissances, nous recommandons de visualiser ce tutoriel vidéo qui présente la création d'une première fenêtre avec PyQt6, incluant l'installation et l'exécution de votre application.
FAQ - Questions Fréquentes
Références
- Créer votre première fenêtre - Python GUIs
- Fenêtre de base en PyQt6 - Python Guides
- Tutoriel PyQt6 - Coders Legacy
- Guide pour débutants - Educative
- Multiples fenêtres en PyQt6 - Python GUIs
Recommandé
Last updated March 31, 2025