Créer des interfaces Python modernes et fluides avec PyQt6

J'ai un aveu à faire : pendant longtemps, quand un dev me montrait fièrement son app Python avec un bouton gris carré et une Listbox qui sentait Windows 95, je hochais la tête poliment. Aujourd'hui, j'ai arrêté.

Pas parce que je suis devenu méchant. Parce que PyQt6 existe, et qu'il n'y a plus aucune excuse.

Cet article, c'est ma tentative de te convaincre — toi qui ouvres encore tkinter par réflexe — qu'il existe quelque chose de radicalement mieux. Je vais te montrer pourquoi, à travers des comparaisons côte à côte et des extraits réels du projet sur lequel je bosse depuis des mois : WatchTower, un système de monitoring de défacement web construit entièrement avec PyQt6.

Spoiler : à la fin, tu vas vouloir réécrire tout ce que tu as fait avec Tkinter.

Le dashboard principal de WatchTower. 100 % PyQt6, sans framework JS, sans Electron.

Le drame Tkinter en trois lignes

Soyons honnêtes deux secondes. Tkinter est livré avec Python, c'est gratuit, c'est documenté, et ça marche. Voilà. C'est le seul argument. Le reste, c'est du masochisme.

# Tkinter — un "dashboard" qui fait pleurer
import tkinter as tk
from tkinter import ttk

root = tk.Tk()
root.title("Mon super outil")
root.geometry("400x300")

label = tk.Label(root, text="Statut : OK", bg="grey", fg="white")
label.pack(pady=10)

button = tk.Button(root, text="Scanner")
button.pack()

root.mainloop()

Tu obtiens un truc gris, plat, et qui te crie « 1998 » en pleine figure. Tu veux changer la police ? Tu te bagarres avec font=("Arial", 10). Tu veux un thème sombre ? Bon courage. Tu veux un graphique en temps réel ? Tu intègres matplotlib au chausse-pied et tu pries.

La même chose en PyQt6

Maintenant regarde le même bidule en PyQt6 :

# PyQt6 — propre, moderne, et stylable
import sys
from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QLabel, QPushButton, QVBoxLayout, QWidget
)

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Mon super outil")
        self.resize(400, 300)

        central = QWidget()
        layout = QVBoxLayout(central)

        self.label = QLabel("Statut : OK")
        self.button = QPushButton("Scanner")
        self.button.clicked.connect(self.on_scan)

        layout.addWidget(self.label)
        layout.addWidget(self.button)
        self.setCentralWidget(central)

        self.setStyleSheet("""
            QMainWindow { background-color: #282c34; }
            QLabel { color: #61afef; font-size: 14pt; font-weight: bold; }
            QPushButton {
                background-color: #61afef; color: #282c34;
                border-radius: 6px; padding: 8px 16px; font-weight: bold;
            }
            QPushButton:hover { background-color: #56a4e0; }
        """)

    def on_scan(self):
        self.label.setText("Scan en cours...")

app = QApplication(sys.argv)
window = MainWindow()
window.show()
sys.exit(app.exec())

À peine plus de lignes. Mais le résultat ? Une fenêtre sombre, un bouton avec coins arrondis, un effet hover, et une typo lisible. Et tout ça sans installer un seul thème externe.

Tkinter (à gauche) vs PyQt6 (à droite). Devine lequel donne envie de cliquer.

Pourquoi PyQt6 change la donne

1. Les stylesheets (QSS), c'est du CSS pour ton app

C'est probablement la fonctionnalité la plus sous-estimée de Qt. Tu connais CSS ? Alors tu connais déjà 80 % de QSS. Voici un extrait du thème sombre que j'utilise dans WatchTower :

QWidget {
    background-color: #282c34;
    color: #abb2bf;
    font-family: "Segoe UI", "Roboto", sans-serif;
    font-size: 10pt;
}
QPushButton {
    background-color: #3a3f4b;
    border: 1px solid #4b5263;
    border-radius: 4px;
    padding: 6px 12px;
}
QPushButton:hover { background-color: #4b5263; }
QHeaderView::section {
    background-color: #21252b;
    color: #e6efff;
    padding: 6px;
}

Tu charges ça depuis un fichier .qss, tu l'appliques avec app.setStyleSheet(qss), et toute l'application est habillée d'un coup. Thème clair, sombre, cyan, accessible : il suffit de switcher la string. Avec Tkinter, tu changeais ça widget par widget, à la main, en pleurant.

2. Le système signaux/slots, c'est un super-pouvoir

Dans Tkinter, la communication entre composants se fait avec des callbacks et des variables globales tristes. En Qt, chaque widget peut émettre des signaux, et n'importe qui peut s'y connecter.

Dans WatchTower, j'ai des cartes KPI cliquables qui émettent un signal card_clicked portant le titre de la carte (« ALERTES ACTIVES », « SITES SURVEILLÉS », etc.). Le dashboard écoute ce signal et filtre la liste en conséquence :

from PyQt6.QtCore import pyqtSignal
from PyQt6.QtWidgets import QFrame

class KpiCard(QFrame):
    card_clicked = pyqtSignal(str)  # déclare un signal qui émet une string

    def mousePressEvent(self, event):
        self.card_clicked.emit(self.title)
        super().mousePressEvent(event)

# Côté dashboard :
self.alerts_card.card_clicked.connect(self.filter_by_category)

C'est découplé, testable, et ça scale. Le widget ne sait pas qui l'écoute, et le listener ne sait pas d'où vient le signal. Du vrai event-driven, pas du command=lambda: ... empilé sur trois étages.

3. Le threading qui ne fait pas freezer ton UI

Le pire moment d'une app Tkinter, c'est quand tu lances une opération longue et que la fenêtre devient blanche pendant 30 secondes. Tu connais. Tout le monde connaît.

PyQt te donne QThread et QRunnable avec QThreadPool, et les signaux marchent à travers les threads. Concrètement, dans WatchTower, mon scanner async tourne dans un worker dédié et envoie les résultats à l'UI via signaux :

from PyQt6.QtCore import QThread, pyqtSignal

class ScanWorker(QThread):
    progress = pyqtSignal(int, str)        # %, message
    site_done = pyqtSignal(dict)           # résultat structuré
    finished = pyqtSignal()

    def __init__(self, sites):
        super().__init__()
        self.sites = sites

    def run(self):
        for i, site in enumerate(self.sites):
            result = self.scan_one(site)   # blocking, mais c'est OK ici
            self.progress.emit(int(100 * (i+1) / len(self.sites)), site["url"])
            self.site_done.emit(result)
        self.finished.emit()

# Dans la fenêtre principale :
self.worker = ScanWorker(my_sites)
self.worker.progress.connect(self.statusBar().showMessage)
self.worker.site_done.connect(self.dashboard.add_result)
self.worker.start()

L'UI reste fluide. Tu peux scroller, cliquer ailleurs, ouvrir un dialog. Tkinter ne fait pas ça nativement, et les workarounds avec threading + after() sont fragiles.

4. Les widgets qu'on attend en 2026

Tkinter te donne une Listbox. Qt te donne QListView, QTableView, QTreeView avec un système modèle/vue (MVC), tri, filtre, édition inline, drag & drop, virtualisation pour des millions de lignes. Tu peux brancher un QSortFilterProxyModel au-dessus de ton modèle et obtenir une recherche textuelle gratuite.

Pour les graphiques en temps réel, tu as QtCharts (officiel) ou pyqtgraph (très rapide, parfait pour du monitoring). Dans WatchTower, j'affiche en live l'évolution des alertes et la consommation CPU sans aucun freeze.

Quatre sites surveillés en parallèle avec leur vrai rendu HTML. Bonne chance à faire ça en Tkinter.

Et pour les icônes ? Une seule ligne avec qtawesome :

import qtawesome as qta
button.setIcon(qta.icon("fa5s.shield-alt", color="#61afef"))

Des milliers d'icônes Font Awesome, Material Design, Elusive — colorables, redimensionnables, vectorielles.

WatchTower, le projet qui m'a fait basculer

J'ai construit WatchTower, un système de monitoring de défacement web, pour avoir un tableau de bord temps réel surveillant des dizaines de sites. Voici ce que PyQt6 m'a permis de faire sans douleur :

• Dashboard moderne avec cartes KPI cliquables, statistiques live, et grille multi-sites (1, 2 ou 4 sites en parallèle)
• WebViews intégrées (QWebEngineView) qui affichent le rendu réel des sites surveillés — impossible à faire proprement en Tkinter
• Système de thèmes : sombre, clair, cyan, switchable à chaud sans relancer l'app
• Workers async qui scannent en parallèle sans figer l'interface
• Timeline d'incidents, dialogs de configuration multi-onglets, system tray, notifications natives, génération de rapports PDF…

Chaque brique de l'UI est un widget réutilisable qui émet ses propres signaux. Quand j'ajoute une nouvelle source de données, je n'ai pas à réécrire la moitié de l'interface : je connecte un signal, et c'est plié.

Sept onglets, chacun étant un widget indépendant. C'est ça, la modularité.

Le même projet en Tkinter ? Soit il n'aurait pas existé, soit il aurait fait 10 000 lignes de spaghetti.

« Mais Tkinter est dans la stdlib ! »

Oui. Et urllib aussi, mais tout le monde utilise requests. La performance et l'ergonomie comptent plus que l'absence d'un pip install.

Pour info :

pip install PyQt6 qtawesome pyqtgraph

Et tu as de quoi faire des apps qui ressemblent à des outils pros, pas à un TP de L1.

Et PyQt6 vs PyQt5 ?

J'ai démarré sur PyQt5, je suis passé à PyQt6 il y a un moment. Les différences principales :

• Enums namespacées : Qt.AlignCenter devient Qt.AlignmentFlag.AlignCenter. Plus verbeux, mais beaucoup plus clair.
• exec_() devient exec() : Python 3 a libéré le mot-clé.
• Plus propre, mieux typé, et c'est la version sur laquelle Qt continue d'investir.

Si tu démarres aujourd'hui, va directement sur PyQt6 (ou PySide6 si tu veux la licence LGPL).

Par où commencer

1. pip install PyQt6
2. Code une fenêtre minuscule. Ressens la satisfaction d'un bouton qui a l'air normal.
3. Découvre QSS, joue avec un thème sombre.
4. Fais ton premier signal/slot custom.
5. Ajoute qtawesome et pyqtgraph quand tu veux passer au niveau au-dessus.

La doc de Qt est dense mais excellente, et 90 % du temps, ce que tu cherches existe déjà comme widget officiel.

Conclusion

Faire des interfaces moches en 2026 est un choix, pas une fatalité. PyQt6 te donne du QSS façon CSS, des signaux/slots qui tiennent la route, du threading propre, et un catalogue de widgets qui couvre la quasi-totalité des besoins.

Si tu veux voir ce que ça donne à grande échelle, j'ai mis WatchTower en open-source sur github.com/hi3ris, et le reste de mes projets traîne sur hi3ris.blueshield.tg si tu veux jeter un œil. Et si après ça tu reviens à Tkinter pour ta prochaine app desktop, c'est qu'on n'aura vraiment pas eu la même conversation.

Allez, à toi de jouer. Et arrête de pondre des Listbox grises.

---

Si cet article t'a parlé, lâche un ❤️ et un 🦄 — et dis-moi en commentaire le pire crime UI que tu aies commis avec Tkinter. Promis, pas de jugement (enfin, un peu).