Tutoriel PySide6 : créer des applications GUI avec Python

Soyons honnêtes : les parties prenantes non techniques, ou les utilisateurs finaux, ne s’intéressent pas aux Jupyter Notebooks ni aux scripts Python que vous créez en tant que praticien des données. Ils veulent interagir avec la solution et voir les résultats par eux‑mêmes.

C’est pourquoi nous devons transformer notre travail en rapports d’insights, en tableaux de bord ou en applications de data science. Si les rapports, les dashboards et les applications web sont monnaie courante, une alternative moins explorée reste les applications de bureau.

Imaginez pouvoir concevoir une appli où les utilisateurs cliquent sur des boutons, remplissent des formulaires et naviguent dans des menus — le tout via une interface claire et agréable sur leur ordinateur. Plutôt cool, non ?

Dans ce tutoriel, nous allons présenter PySide6, vous guider dans les premières installations et construire votre première application de bureau. Nous passerons en revue les widgets les plus utilisés, intégrerons des visualisations issues de bibliothèques de data science populaires et partagerons des ressources utiles.

Qu’est‑ce que PySide6 ?

PySide6 est une boîte à outils qui vous permet de créer des applications logicielles en Python avec des interfaces graphiques attractives et intuitives.

C’est un peu comme un jeu de briques pour logiciels : même les débutants peuvent assembler les éléments visuels et interactifs d’une application. Avec PySide6, vous transformez vos idées en applications réelles et fonctionnelles sur Windows, Mac, Linux, et même sur mobile.

Configurer PySide6

Nous partons du principe que Python est déjà installé et que vous disposez de votre IDE habituel. L’installation est très simple.

Ouvrez votre terminal, exécutez la commande suivante, et le tour est joué.

pip3 install pyside6

Créer votre première application PySide6

Maintenant que la bibliothèque est installée, passons à la création de votre première application PySide6. C’est aussi l’occasion de vérifier que tout fonctionne, tout en vous donnant un aperçu des applications de bureau.

Créez un fichier Python nommé « main.py » et copiez‑collez le code suivant.

import sys
from PySide6.QtWidgets import QApplication, QLabel
app = QApplication(sys.argv)
label = QLabel('Hello, PySide6!')
label.show()
sys.exit(app.exec_())

Nous allons expliquer ce code dans un instant. D’abord, exécutez le fichier Python depuis votre terminal comme suit :

python3 run main.py

Félicitations, vous venez de créer votre première application de bureau ! Vous devriez voir ceci :

L’application de bureau « Hello, PySide6 » (image de l’auteur)

Décortiquons maintenant le script PySide6. On importe d’abord les modules nécessaires :

import sys
from PySide6.QtWidgets import QApplication, QLabel

• sys est un module standard de Python qui donne accès à certaines variables utilisées ou maintenues par l’interpréteur. Dans une application PySide6, il sert souvent à récupérer les arguments de la ligne de commande. Pour en savoir plus, consultez notre tutoriel sur l’analyse des arguments en ligne de commande.
• QApplication et QLabel sont importés depuis PySide6.QtWidgets. QApplication est la classe centrale de gestion d’application, indispensable à toute application GUI. QLabel est un widget qui affiche du texte, que nous utilisons ici pour montrer un message simple.

Ensuite, nous créons une instance de QApplication.

app = QApplication(sys.argv)

C’est requis dans toute application PySide6. sys.argv sert à transmettre les arguments de la ligne de commande à l’application. Même si vous ne les utilisez pas, sys.argv reste nécessaire, car il initialise QApplication avec des valeurs par défaut.

label = QLabel('Hello, PySide6!')

Nous créons ensuite un widget QLabel avec le texte "Hello, PySide6!". C’est le texte affiché dans la fenêtre de l’application.

label.show()

Cette ligne rend le label visible. Par défaut, les widgets PySide6 ne sont pas visibles tant que vous ne les affichez pas explicitement.

sys.exit(app.exec_())

Enfin, cette ligne lance la boucle d’événements de l’application. La méthode exec_() de QApplication entre dans la boucle principale où tous les événements (clics souris, frappes clavier, etc.) sont traités. L’appel à sys.exit() garantit une fermeture propre lorsque l’application se termine. La boucle tourne jusqu’à ce que l’instance de QApplication reçoive un signal de sortie, comme la fermeture de la fenêtre.

Comme on l’a vu, notre script crée une application GUI basique à une seule fenêtre affichant le texte « Hello, PySide6! ».

Intégrer des widgets PySide6 dans l’application GUI

Dans PySide6 et les interfaces graphiques, les widgets sont les briques de base utilisées pour construire l’interface utilisateur. Pensez aux widgets comme aux éléments que vous voyez et manipulez dans toute application — boutons, zones de texte, étiquettes, curseurs, menus déroulants, etc.

Dans la première application PySide6, nous avons utilisé un widget d’étiquette pour afficher du texte. Quand on construit une interface avec PySide6, on organise ces widgets dans une fenêtre de manière cohérente pour notre cas d’usage. Chaque widget a un rôle précis et interagit différemment avec l’utilisateur.

La liste complète des widgets et leurs usages figure dans la documentation officielle, mais les plus courants sont :

• QLabel : widget d’affichage de texte ou d’images. Souvent utilisé pour des instructions, des messages, ou l’affichage d’images.
• QPushButton : bouton cliquable permettant de déclencher des actions. C’est l’un des widgets fondamentaux pour soumettre des formulaires, lancer des processus, etc.
• QLineEdit : champ de saisie sur une ligne. Très courant dans les formulaires et paramètres nécessitant une entrée texte (nom, nombre…).
• QComboBox : combinaison d’une liste déroulante et d’un champ texte, pour choisir parmi des options prédéfinies ou saisir sa propre valeur.
• QCheckBox : case à cocher, pour activer/désactiver des fonctionnalités ou marquer un accord (p. ex. conditions générales).
• QRadioButton : bouton radio pour sélectionner une seule option au sein d’un groupe — idéal pour des choix exclusifs.
• QTextEdit : zone d’édition multi‑ligne, plus riche que QLineEdit (mise en forme, copier‑coller, défilement).
• QSlider : curseur, pratique pour saisir une valeur numérique dans un intervalle (volume, filtre de prix…).
• QSpinBox : sélecteur numérique avec flèches haut/bas pour augmenter ou diminuer une valeur.
• QProgressBar : barre de progression, pour visualiser l’avancement d’une tâche (téléversement, téléchargement…).
• QTableWidget : affichage de données en tableau, organisé en lignes et colonnes pour manipuler des données structurées.

Créons une application qui utilise et affiche ces widgets courants :

import sys
from PySide6.QtWidgets import QApplication, QMainWindow, QLabel, QPushButton, QLineEdit, QComboBox, QCheckBox, QRadioButton, QTextEdit, QSlider, QSpinBox, QProgressBar, QTableWidget, QTableWidgetItem, QVBoxLayout, QHBoxLayout, QWidget

class DemoWindow(QMainWindow):
   def __init__(self):
       super().__init__()

       # Main Widget and Layout
       main_widget = QWidget()
       self.setCentralWidget(main_widget)
       main_layout = QVBoxLayout(main_widget)

       # Function to add widget with label
       def add_widget_with_label(layout, widget, label_text):
           hbox = QHBoxLayout()
           label = QLabel(label_text)
           hbox.addWidget(label)
           hbox.addWidget(widget)
           layout.addLayout(hbox)

       # QLabel
       self.label = QLabel('Hello PySide6!')
       add_widget_with_label(main_layout, self.label, 'QLabel:')

       # QPushButton
       self.button = QPushButton('Click Me')
       self.button.clicked.connect(self.on_button_clicked)
       add_widget_with_label(main_layout, self.button, 'QPushButton:')

       # QLineEdit
       self.line_edit = QLineEdit()
       add_widget_with_label(main_layout, self.line_edit, 'QLineEdit:')

       # QComboBox
       self.combo_box = QComboBox()
       self.combo_box.addItems(['Option 1', 'Option 2', 'Option 3'])
       add_widget_with_label(main_layout, self.combo_box, 'QComboBox:')

       # QCheckBox
       self.check_box = QCheckBox('Check Me')
       add_widget_with_label(main_layout, self.check_box, 'QCheckBox:')

       # QRadioButton
       self.radio_button = QRadioButton('Radio Button')
       add_widget_with_label(main_layout, self.radio_button, 'QRadioButton:')

       # QTextEdit
       self.text_edit = QTextEdit()
       add_widget_with_label(main_layout, self.text_edit, 'QTextEdit:')

       # QSlider
       self.slider = QSlider()
       add_widget_with_label(main_layout, self.slider, 'QSlider:')

       # QSpinBox
       self.spin_box = QSpinBox()
       add_widget_with_label(main_layout, self.spin_box, 'QSpinBox:')

       # QProgressBar
       self.progress_bar = QProgressBar()
       add_widget_with_label(main_layout, self.progress_bar, 'QProgressBar:')

       # QTableWidget
       self.table_widget = QTableWidget(5, 3) 
       for i in range(5):
           for j in range(3):
               item = QTableWidgetItem(f"Cell {i+1},{j+1}")
               self.table_widget.setItem(i, j, item)
       add_widget_with_label(main_layout, self.table_widget, 'QTableWidget:')

   def on_button_clicked(self):
       self.label.setText('Button Clicked!')

# Run the application
app = QApplication(sys.argv)
window = DemoWindow()
window.show()
sys.exit(app.exec_())

Le résultat est le suivant :

Application de bureau des widgets (image de l’auteur)

Nous avons créé une application de bureau qui regroupe les widgets les plus courants. Pour plus de clarté, nous avons ajouté une étiquette à côté de chaque widget. Même s’il s’agit d’un exemple, nous pouvons désormais piocher dans ces widgets populaires pour nos applications plus complexes.

Une application de visualisation de données avec PySide6, Matplotlib et Seaborn

Pour cette application, nous allons d’abord choisir un jeu de données connu et créer des visualisations indépendantes. Cette étape ressemble à l’analyse exploratoire que nous faisons au quotidien. Ensuite, nous encapsulerons ces visualisations dans une application de bureau, à l’image d’un rapport qui devient interactif.

Avant de commencer, assurons‑nous d’avoir toutes les bibliothèques nécessaires en exécutant la commande suivante dans le terminal.

pip3 install matplotlib seaborn

Étape 1 : créer des visualisations simples et autonomes

Nous chargeons ici le célèbre « jeu de données iris » disponible nativement dans le package de visualisation Python — Seaborn. Nous utilisons ce package, ainsi que Matplotlib, pour créer les visuels. Pour une vue d’ensemble complète de Seaborn, consultez notre guide de visualisation Python Seaborn.

import seaborn as sns
import matplotlib.pyplot as plt
# Load the Iris dataset
iris = sns.load_dataset("iris")

Puis, nous créons les visualisations suivantes :

plt.figure(figsize=(6, 4))
sns.scatterplot(data=iris, x="sepal_length", y="sepal_width", hue="species")
plt.title("Sepal Length vs Sepal Width")
plt.show()

La première visualisation est un nuage de points longueur de sépale vs largeur de sépale, coloré par espèce.

Visualisation #1 : longueur de sépale vs largeur de sépale (image de l’auteur)

La deuxième visualisation est un histogramme de la longueur des pétales, coloré par espèce.

plt.figure(figsize=(6, 4))
sns.histplot(iris, x="petal_length", hue="species", kde=True)
plt.title("Histogram of Petal Length")
plt.show()

Et voici le résultat :

Visualisation #2 : histogramme de la longueur des pétales (image de l’auteur)

Enfin, traçons un box‑plot montrant la distribution de la largeur des pétales selon les espèces.

plt.figure(figsize=(6, 4))
sns.boxplot(x="species", y="petal_width", data=iris)
plt.title("Box Plot of Petal Width")
plt.show()

La visualisation obtenue :

Ces graphiques offrent différentes perspectives sur le jeu de données Iris, en mettant en évidence relations et distributions des variables selon les espèces.

Étape 2 : intégrer les visualisations dans l’application de bureau

Voyons d’abord le code, puis expliquons‑le.

import sys
import seaborn as sns
from PySide6.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure

class IrisVisualizer(QMainWindow):
   def __init__(self):
       super().__init__()
       self.setWindowTitle("Iris Dataset Visualizations")
       self.setGeometry(100, 100, 1200, 900)  # x, y, width, height
       self.initUI()

   def initUI(self):
       central_widget = QWidget(self)
       self.setCentralWidget(central_widget)
       layout = QVBoxLayout(central_widget)

       # Adding multiple plots
       self.addScatterPlot(layout)
       self.addHistogram(layout)
       self.addBoxPlot(layout)

   def addPlotCanvas(self, layout, plot_func):
       canvas = FigureCanvas(Figure(figsize=(6, 4)))
       plot_func(canvas.figure)
       layout.addWidget(canvas)

   def addScatterPlot(self, layout):
       def scatter_plot(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.scatterplot(data=iris, x="sepal_length", y="sepal_width", hue="species", ax=ax)
           ax.set_title("Sepal Length vs Sepal Width")

       self.addPlotCanvas(layout, scatter_plot)

   def addHistogram(self, layout):
       def histogram(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.histplot(iris, x="petal_length", hue="species", kde=True, ax=ax)
           ax.set_title("Histogram of Petal Length")

       self.addPlotCanvas(layout, histogram)

   def addBoxPlot(self, layout):
       def box_plot(figure):
           iris = sns.load_dataset("iris")
           ax = figure.add_subplot(111)
           sns.boxplot(x="species", y="petal_width", data=iris, ax=ax)
           ax.set_title("Box Plot of Petal Width")

       self.addPlotCanvas(layout, box_plot)

# Run the application
app = QApplication(sys.argv)
window = IrisVisualizer()
window.show()
sys.exit(app.exec_())

Nous structurons l’application autour de la classe IrisVisualizer, qui étend QMainWindow de PySide6. Elle configure la fenêtre principale et sa mise en page, servant de conteneur aux visualisations. Chaque graphique est intégré à l’interface via FigureCanvasQTAgg de Matplotlib, qui permet d’afficher des figures Matplotlib comme des widgets PySide6.

Le cœur de l’intégration réside dans la méthode addPlotCanvas. Elle crée une figure Matplotlib, y dessine un graphique, puis l’intègre dans le layout de l’application. Les méthodes addScatterPlot, addHistogram et addBoxPlot définissent respectivement les graphiques — ceux que nous avions construits de façon autonome plus haut. La fenêtre principale utilise un layout vertical (QVBoxLayout) qui empile les graphiques les uns sous les autres.

Voici l’application finale :

Application de bureau de visualisations du jeu de données Iris (image de l’auteur)

N’est‑ce pas plus convaincant qu’un simple graphique dans un Jupyter Notebook ? Certes, l’exemple est basique, mais une fois les concepts compris, vous pouvez faire évoluer ces bases vers un véritable tableau de bord d’insights ou une application de data science complète.

Conclusion

Ce tutoriel a présenté PySide6, une bibliothèque Python qui permet aux praticiens des données de créer des applications de bureau avec interface graphique, dans leur langage de prédilection — Python. Nous avons commencé par installer PySide6 et créer une première application.

Nous avons ensuite élargi l’exemple pour couvrir les widgets les plus utilisés dans les applications de bureau.

Enfin, nous avons vu comment intégrer des visualisations issues de bibliothèques populaires comme Seaborn et Matplotlib directement dans nos applications PySide6.

Pour aller plus loin, nous vous invitons à consulter la documentation officielle et à laisser libre cours à votre curiosité pour créer vos applications favorites. Vous pouvez aussi découvrir notre tutoriel qui crée des applications de bureau GUI en Python avec une bibliothèque alternative, Tkinter.