Chat
Search
Ithy Logo

Ouvrir une fenêtre en Python avec PyQt6

Guide détaillé pour créer et personnaliser une interface graphique avec PyQt6

scenic view of modern computer workstations

Points essentiels à retenir

  • Installation et configuration : Assurez-vous d'installer PyQt6 via pip et de créer l'objet QApplication pour démarrer l'application.
  • Méthode de création : Vous pouvez opter pour une approche simple avec QWidget ou une approche orientée objet avec QMainWindow pour une personnalisation avancée.
  • Personnalisation et extension : Ajoutez des widgets, configurez la taille, la position, et organisez l'interface avec Qt Designer ou via le code directement.

Introduction

Pour développer une application graphique en Python, PyQt6 est une option très performante et flexible permettant de créer des interfaces graphiques modernes. Ce tutoriel vous guide pas à pas dans la création d'une fenêtre de base, en mettant en lumière l'installation de PyQt6, la configuration de l'application, et l'implémentation de méthodes pour personnaliser une interface graphique. Que vous soyez un débutant ou un développeur expérimenté, cette approche offre une base solide pour développer des applications GUI en Python.

Installation et Configuration de PyQt6

Installation de PyQt6

Avant de commencer à créer une fenêtre, vous devez installer PyQt6. L'installation se fait via pip. Dans votre terminal, exécutez la commande suivante : 

# Installer PyQt6 via pip
pip install PyQt6

Création de l'objet QApplication

Chaque application PyQt6 nécessite la création d'un objet QApplication. Cet objet gère l'ensemble de l'application, notamment la boucle d'événements qui écoute les actions de l'utilisateur. Vous devez également fournir les arguments de la ligne de commande grâce à sys.argv. Sans cet objet, aucune interface ne pourra être affichée.

Création d'une fenêtre de base

Approche simple avec QWidget

Pour débuter, vous pouvez créer une fenêtre simple en utilisant la classe QWidget. Ce widget représente une fenêtre basique qui vous permet d'expérimenter avec l'interface graphique. Voici un exemple minimaliste : 

# Importation des modules nécessaires
import sys
from PyQt6.QtWidgets import QApplication, QWidget

# Création de l'application
app = QApplication(sys.argv)

# Création de la fenêtre 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)

# Affichage de la fenêtre
window.show()

# Démarrage de la boucle d'événements
sys.exit(app.exec())

Ce code crée une fenêtre simple avec un titre et des dimensions définies. La méthode window.show() est cruciale, car sans elle, la fenêtre restera invisible.

Approches avancées et Personnalisation

Utiliser QMainWindow pour des Interfaces Riches

Pour une application plus robuste et personnalisée, il est recommandé d'utiliser QMainWindow. Cette classe offre une structure préconçue avec une barre de menus, une barre d'outils et une barre d'état. Avec QMainWindow, vous pouvez définir un widget central en appelant setCentralWidget(). Voici un exemple classique d'implémentation utilisant une approche orientée objet : 

# Importation des modules nécessaires
import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QWidget
from PyQt6.QtCore import QSize

# Définition de la classe MainWindow en héritant de QMainWindow
class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()

        # Configuration de la fenêtre principale
        self.setWindowTitle("Ma fenêtre PyQt6")
        self.setFixedSize(QSize(400, 300))  # Définir une taille fixe pour la fenêtre

        # Création et ajout du widget central
        centralWidget = QWidget()
        self.setCentralWidget(centralWidget)

# Point d'entrée principal de l'application
if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())

En définissant la fenêtre comme une sous-classe de QMainWindow, vous pouvez aisément ajouter d'autres composants, comme des menus ou des barres d'outils, et structurer le contenu graphique de votre application.

Utiliser Qt Designer pour concevoir votre interface

Qt Designer est un outil graphique qui permet aux développeurs de concevoir des interfaces de manière visuelle et intuitive. Vous pouvez créer votre fenêtre en glissant-déposant des widgets, puis enregistrer le fichier d'interface au format .ui. Ensuite, vous pouvez charger ce fichier dans votre script Python avec la bibliothèque uic. 

# Exemple d'importation d'un fichier .ui généré par Qt Designer
from PyQt6 import uic
from PyQt6.QtWidgets import QApplication, QMainWindow
import sys

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        # Chargement de l'interface générée par Qt Designer
        uic.loadUi("mon_interface.ui", self)
        
if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())

Cette méthode permet de séparer clairement le design de l'interface de la logique de l'application, facilitant ainsi la maintenance et les évolutions futures.

Validation des concepts avec un tableau explicatif

Tableau comparatif de QMainWindow et QWidget

Aspect QWidget QMainWindow
Utilisation Fenêtres simples, boîtes de dialogue Fenêtres principales d’application avec menus et barres d’outils
Structure Basique, aucun emplacement prédéfini Contient des zones prédéfinies telles que la barre de menus, barre d'outils, et barre d'état
Personnalisation Essentiellement définie par le développeur Possède une structure préconfigurée permettant une personnalisation avancée
Configuration Simple et directe Nécessite la définition d'un widget central avec setCentralWidget()

Ce tableau met en lumière les différences essentielles entre QWidget et QMainWindow. Tandis que QWidget est efficace pour des fenêtres simples, QMainWindow est recommandé pour des applications complètes nécessitant plus d'interactivité et des menus.

Ouverture de fenêtrage multiple

Une application peut nécessiter l'ouverture de plusieurs fenêtres ou dialogues. Pour cela, il est possible de créer des fenêtres supplémentaires par la simple instanciation d'un widget (ou d'une sous-classe QMainWindow) et en appelant la méthode show() sur l'instance. Voici comment procéder pour ouvrir une deuxième fenêtre à partir d'un bouton dans la première fenêtre : 

# Exemple d'ouverture d'une nouvelle fenêtre
import sys
from PyQt6.QtWidgets import QApplication, QMainWindow, QPushButton, QWidget

class SecondaryWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Fenêtre Secondaire")
        self.setGeometry(150, 150, 300, 200)

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Fenêtre Principale")
        self.setGeometry(100, 100, 500, 400)
        button = QPushButton("Ouvrir une nouvelle fenêtre", self)
        button.clicked.connect(self.open_new_window)
        button.setGeometry(150, 100, 200, 40)
    
    def open_new_window(self):
        self.second_window = SecondaryWindow()
        self.second_window.show()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())

Dans cet exemple, l'action sur le bouton déclenche l'exécution d'une méthode qui crée et affiche une seconde fenêtre. Ce mécanisme vous permet de construire des applications complexes avec plusieurs interfaces.

Personnalisation et Fonctions Avancées

Définir la Géométrie de la Fenêtre

La configuration de la position et des dimensions de la fenêtre est gérée par la méthode setGeometry(x, y, width, height). Pour une fenêtre non redimensionnable, vous pouvez employer la méthode setFixedSize(). De plus, centrer la fenêtre sur l'écran permet d'améliorer l'ergonomie et l'esthétique de l'interface utilisateur.

Fonction pour centrer la fenêtre

def center_window(window):
    # Récupère la géométrie du cadre
    frameGm = window.frameGeometry()
    # Obtient l'écran primaire de l'application
    screen = QApplication.primaryScreen()
    # Récupère le centre de l'écran disponible
    centerPoint = screen.availableGeometry().center()
    # Déplace le cadre pour qu'il soit centré
    frameGm.moveCenter(centerPoint)
    window.move(frameGm.topLeft())

En utilisant cette fonction juste après la configuration de la géométrie, vous pouvez garantir que votre fenêtre apparaisse bien centrée sur tous les écrans disponibles.

Ajout de Widgets et D'Autres Composants

Pour rendre votre interface plus interactive, vous pouvez ajouter divers widgets tels que des boutons, des labels, et des barres de menus. Par exemple, l’ajout d’un QLabel à une fenêtre simple Java permet d’afficher des informations textuelles: 

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

app = QApplication(sys.argv)
window = QWidget()
window.setWindowTitle("Fenêtre avec Label")
window.setGeometry(100, 100, 400, 300)

# Création d'un label
label = QLabel("Bonjour, bienvenue dans PyQt6!", window)
label.move(50, 50)

window.show()
sys.exit(app.exec())

L'ajout de fonctionnalités telles que des menus, des barres d'outils, et d'autres widgets enrichit l'expérience utilisateur et permet de créer des applications plus interactives et professionnelles.

Exemples pratiques et conseils supplémentaires

Lors de la création d'une application avec PyQt6, il est important de suivre quelques bonnes pratiques :

  • Structure du code : Organisez votre code en utilisant des classes et des méthodes pour faciliter la maintenance et la réutilisation.
  • Utilisation de Qt Designer : Pour les interfaces complexes, envisagez d'utiliser Qt Designer pour gagner du temps et éviter des erreurs de mise en page.
  • Gestion de l'événement : La compréhension de la boucle d'événements et des signaux Qt est essentielle pour créer des applications réactives.

À mesure que vous gagnez en expérience avec PyQt6, vous pouvez explorer des fonctionnalités plus avancées telles que l'intégration de bases de données, la gestion des threads, et l'utilisation de styles personnalisés pour améliorer l'apparence de votre interface. En particulier, la gestion asynchrone des tâches peut être cruciale pour les applications en temps réel, garantissant que l'interface reste fluide même lors de traitements lourds.

Pour résumer, la création et la gestion d'une fenêtre en Python avec PyQt6 impliquent principalement l'installation et la configuration de l'environnement, le choix de l'approche (simple ou orientée objet), la personnalisation de l'interface et l'ajout de fonctionnalités supplémentaires par le biais d'une gestion fine des événements. Ce guide détaillé vous permet d'approfondir chacun de ces aspects, vous offrant ainsi une base solide pour développer des interfaces graphiques complètes.

Conclusion

En conclusion, ouvrir une fenêtre en Python avec PyQt6 nécessite de comprendre à la fois le fonctionnement de l'objet QApplication et les différentes classes de widgets disponibles. Que vous choisissiez d'utiliser un simple QWidget ou une structure plus complète avec QMainWindow, vous aurez la flexibilité d'ajouter des fonctionnalités avancées telles que des menus, des barres d'outils et des dialogues. La maîtrise de cette approche vous permet de créer des applications graphiques professionnelles et intuitives. Le recours à des outils comme Qt Designer pour concevoir visuellement votre interface facilite encore le processus, vous permettant de séparer le design de la logique de l'application. Avec ces techniques en main, vous êtes bien équipé pour créer des interfaces riches et interactives avec PyQt6 en Python.

References

Recommended


Last updated February 25, 2025
Ask Ithy AI
Export Article
Delete Article
About|Privacy|Terms||