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.
watchtower-dashboard.png— capture du dashboard principal de WatchTower (KPI cards, chart historique, table des sites, side panel). Sert aussi de cover image.
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-vs-pyqt6-mockup.png — comparaison côte à côte (mockup généré, dans le dossier dev.to/).
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.
📸
watchtower-grid-view.png— la vue multi-sites (4 sites en parallèle avec QWebEngineView).
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é.
watchtower-config.png— dialog de configuration multi-onglets (Général, Sites Signatures, Réputation, Alertes…). Le genre de chose impossible à faire proprement en Tkinter.
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.AlignCenterdevientQt.AlignmentFlag.AlignCenter. Plus verbeux, mais beaucoup plus clair. -
exec_()devientexec(): 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
pip install PyQt6- Code une fenêtre minuscule. Ressens la satisfaction d'un bouton qui a l'air normal.
- Découvre
QSS, joue avec un thème sombre. - Fais ton premier signal/slot custom.
- Ajoute
qtawesomeetpyqtgraphquand 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.