PyGTK : l’outil de création d’interface graphique en Python

PyGTK est un module Python permettant de créer une interface utilisateur graphique (GUI) pour une application. Découvrez tout ce que vous devez savoir sur cet outil et son successeur PyGObject : fonctionnement, avantages et inconvénients, formations…

Une interface graphique utilisateur est indispensable pour une application moderne. Elle permet aux utilisateurs d’interagir en toute simplicité. Afin de créer une telle GUI pour un programme en Python, on utilise généralement le module PyGTK.

Qu’est-ce que PyGTK ?

PyGTK est un module Python qui fournit des liaisons (wrappers) pour la bibliothèque d’interface graphique GTK+ afin de créer des interfaces utilisateur en Python. Créé par James Henstridge, il met à disposition des widgets et des signaux GTK directement depuis le code Python. Le nom combine le langage Python et GTK (GIMP ToolKit). Ce projet open source sous licence LGPL est multiplateforme et fonctionne sur Unix/Linux et Windows, dans l’écosystème GNOME. Pour des parcours orientés Data & IA, voir la formation Data Scientist.

Contexte historique : PyGTK a d’abord ciblé GTK 1.2, puis surtout GTK 2.x. Il a été très utilisé pour prototyper rapidement des applications et bâtir des GUI natives. Avec l’arrivée de GTK 3, la communauté a cessé d’étendre PyGTK au profit de PyGObject, basé sur l’Introspection GObject. En pratique, PyGTK est considéré comme une technologie héritée centrée sur GTK 2, et n’est pas le chemin recommandé pour Python 3, remplacé par PyGObject.

PyGTK vs GTK : GTK est le toolkit graphique écrit en C, qui définit les widgets, événements et thèmes. PyGTK est la couche de bindings qui expose ces mêmes fonctionnalités GTK+ 2.x au développeur Python. Aujourd’hui, lorsque l’on parle de “GTK en Python”, on fait référence à PyGObject avec GTK 3/4. Le terme PyGTK désigne spécifiquement l’ancienne liaison Python vers GTK+ 2, à ne pas confondre avec GTK lui-même ni avec PyGObject, son successeur moderne.

À quoi sert PyGTK ?

On utilise principalement PyGTK pour la création d’interfaces graphiques utilisateur (GUI) en Python. Une interface regroupe une fenêtre et sa collection de widgets, incluant des boîtes de dialogue, des cases à cocher, des boutons, du texte et d’autres éléments.

À quoi cela sert concrètement ? Voici les cas d’usage les plus courants :

• Applications desktop multiplateformes : éditeurs légers, lecteurs multimédia, gestionnaires de fichiers ou de collections qui doivent fonctionner sous Linux et Windows.
• Outils internes d’entreprise : frontaux graphiques pour des scripts d’administration ou d’exploitation, par exemple lancer un traitement de fichiers, paramétrer un job planifié, visualiser des journaux d’exécution.
• Utilitaires de productivité : convertisseurs d’images ou d’audio, renommage en lot, petits assistants pour automatiser une tâche récurrente.
• Installateurs et assistants pas à pas : guides de configuration locale, boîtes de dialogue successives pour déployer ou mettre à jour un logiciel.
• Tableaux de bord locaux et monitoring : affichage de métriques, jauges de progression et boutons d’action pour piloter un service qui tourne en arrière-plan.
• Prototypage rapide : maquettes d’interface pour tester l’ergonomie et les interactions avant d’industrialiser.
• Interfaces pour scripts en ligne de commande : offrir des champs, listes et barres de progression à des commandes existantes pour les rendre accessibles sans terminal.
• Outils éducatifs ou scientifiques : petites applications pour manipuler des données, afficher des graphiques 2D ou contrôler un instrument local.

Dans tous ces scénarios, la GUI émet des signaux vers le programme dès qu’un utilisateur interagit avec la fenêtre ou ses widgets, ce qui permet de déclencher une réponse adaptée en temps réel.

Cas concret : un data engineer emballe un script de nettoyage de fichiers CSV dans une petite fenêtre avec sélection de dossier, bouton Lancer, barre de progression et zone de log, afin que des collègues non techniques puissent l’utiliser facilement.

Pour des projets récents basés sur GTK 3 ou 4, on privilégie désormais PyGObject qui remplace PyGTK, mais les usages restent les mêmes pour créer des applications GUI en Python.

PyGTK est-il encore recommandé aujourd’hui ?

Contexte. PyGTK cible GTK+ 2 uniquement et est désormais considéré comme un héritage (legacy). Le dernier paquet officiel publié est la version 2.24.0 du 1 avril 2011, sans maintenance active depuis cette date. Avec l’arrivée de GTK 3, le projet a été remplacé par PyGObject, qui s’appuie sur l’Introspection GObject pour générer les liaisons de manière dynamique. (Sources : GNOME downloads, Wiki Python)

Comparaison. PyGTK fournit des liaisons statiques pour GTK+ 2 et reste lié à Python 2, ce qui limite fortement son usage dans des environnements actuels. À l’inverse, PyGObject fonctionne avec GTK 3 et GTK 4, prend en charge Python 3 et les principaux systèmes (Linux, Windows, macOS). Il bénéficie d’une documentation et d’exemples à jour, ainsi que d’un guide de portage pour migrer un code PyGTK. Pour créer une application Python avec GTK aujourd’hui, la recommandation officielle est d’utiliser PyGObject. (Source : gtk.org)

Synthèse. Pour un nouveau projet en 2026, n’utilisez pas PyGTK. Réservez-le uniquement à la maintenance d’applications historiques sous GTK 2, et planifiez une migration. Pour tout développement moderne, privilégiez PyGObject avec GTK 4 (ou GTK 3 si une dépendance l’exige), afin de profiter d’API maintenues, de Python 3 et d’un écosystème outillé.

Comment installer PyGTK (compatibilité, plateformes) ?

À retenir avant d’installer : PyGTK cible uniquement GTK 2 et Python 2, le projet est figé et a été remplacé par PyGObject pour GTK 3 et GTK 4 avec Python 3. Pour tout nouveau projet, installez PyGObject. Ne conservez PyGTK que pour la maintenance d’anciens logiciels. ([en.wikipedia.org](https://en.wikipedia.org/wiki/PyGTK?utm_source=openai))

Linux

• Nouveaux projets (recommandé) : installez PyGObject fourni par votre distribution.
  • Ubuntu / Debian : sudo apt install python3-gi python3-gi-cairo gir1.2-gtk-4.0 (ou gir1.2-gtk-3.0 selon votre cible). ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/getting_started.html))
  • Fedora : sudo dnf install python3-gobject gtk4. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/getting_started.html))
  • Arch Linux : sudo pacman -S python-gobject gtk4. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/getting_started.html))

  Windows

  • Nouveaux projets (recommandé) : utilisez MSYS2 puis installez GTK et PyGObject : pacman -S mingw-w64-ucrt-x86_64-gtk4 mingw-w64-ucrt-x86_64-python mingw-w64-ucrt-x86_64-python-gobject. Pour exécuter, utilisez le terminal UCRT64 et, si besoin, définissez PYGI_DLL_PATH pour la recherche des DLL. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/getting_started.html))
  • PyGTK historique (GTK 2) : il existait des installateurs all-in-one pour Python 2.6/2.7, par exemple pygtk-all-in-one-2.24.x.win32-py2.7.msi publiés en 2011, 2012. Ces paquets ne fonctionnent pas avec Python 3 et ne sont plus pris en charge. ([download.gnome.org](https://download.gnome.org/binaries/win32/pygtk/2.24/?utm_source=openai))

  macOS

  • Nouveaux projets (recommandé) : via Homebrew : brew install pygobject3 gtk4. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/getting_started.html))
  • PyGTK historique (GTK 2) : des paquets non maintenus ont existé il y a plus de dix ans. Préférez porter le code vers PyGObject. ([sourceforge.net](https://sourceforge.net/projects/zero-install/files/PyGTK/2.24.0/?utm_source=openai))

  Dépendances GTK et précisions techniques

  • GTK 2 vs GTK 3/4 : PyGTK s’appuie sur GTK 2 avec des liaisons statiques. PyGObject expose GTK 3/4 dynamiquement via gi.repository et requiert GObject Introspection et Cairo. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/guide/porting.html?utm_source=openai))
  • Choisir la bonne version de GTK : fixez la major avec gi.require_version("Gtk", "4.0") ou "3.0" pour éviter les collisions de typelibs. ([gtk.org](https://www.gtk.org/docs/language-bindings/python/))
  • Compilation via pip : sous Linux, installez d’abord les entêtes et outils de build de Cairo et GObject Introspection avant pip install PyGObject. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/getting_started.html))

  Avertissements sur les conflits de versions

  • Ne mélangez pas import gtk (PyGTK, statique) et from gi.repository import Gtk (PyGObject) dans un même projet. Le module de compatibilité pygtkcompat est lui-même déprécié. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/guide/porting.html?utm_source=openai))
  • Windows : utilisez la même chaîne d’outils pour Python et les modules natifs. Avec MSYS2, exécutez votre application depuis l’environnement MSYS2 et, si nécessaire, renseignez PYGI_DLL_PATH. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/getting_started.html))
  • Distributions Linux : évitez de mélanger paquets système et pip dans le même environnement virtuel sauf si vous savez gérer les sites système. Suivez les guides de votre distribution. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/getting_started.html))

  Comment créer un Hello World avec PyGTK ?

  Pour illustrer concrètement la création d’une petite fenêtre, voici un exemple minimal. Une interface graphique envoie des signaux au programme dès que l’utilisateur interagit avec la fenêtre ou l’un de ses widgets, puis une fonction de rappel (callback) répond à ces signaux.

  1. Créez un fichier nommé hello_pygtk.py.
  2. Copiez-collez le code suivant (PyGTK historique basé sur GTK 2) :
  3. Exécutez-le depuis un terminal : python hello_pygtk.py.
  4. Une fenêtre « Hello World » s’affiche. Fermez-la pour quitter l’application.

  Astuce : la méthode show_all() affiche la fenêtre et tous les widgets qui y sont ajoutés, ce qui évite d’appeler show() sur chaque élément.

  Vous travaillez avec Python 3 ? PyGTK a été remplacé par PyGObject. Voici l’équivalent moderne avec GTK 3 :

  Se former à la Data Science

  Comment fonctionnent les signaux et la boucle principale ?

  PyGTK propose une API efficace basée sur les signaux et la propagation de callback. Chaque composant peut émettre un signal (clic, fermeture, survol), transmis jusqu’à ce qu’il soit capturé et qu’un appel de fonction de rappel soit déclenché. L’application reste réactive grâce à la boucle principale qui traite les événements.

  • connect() : associe un signal à une fonction de rappel. Exemple : win.connect("destroy", gtk.main_quit).
  • Callbacks : ce sont des fonctions Python appelées quand le signal survient. La signature reçoit au minimum le widget émetteur (et parfois des données supplémentaires).
  • Boucle principale : gtk.main() (PyGTK) ou Gtk.main() (PyGObject) démarre la boucle d’événements. Elle s’arrête avec gtk.main_quit() ou Gtk.main_quit().

  Exemple court avec un bouton qui affiche un message et ferme l’application :

  Retenez l’architecture événementielle : vous créez les widgets, vous reliez leurs signaux à des callbacks avec connect(), vous affichez l’interface, puis la boucle principale (main()) prend en charge les événements jusqu’à la fermeture de la fenêtre.

  Quels modules composent PyGTK ?

  

  PyGTK regroupe plusieurs briques complémentaires pour construire une interface graphique complète en Python. Panorama rapide des modules clés et de leur rôle.

  Module	Rôle principal
  Gtk	Widgets et fenêtres de haut niveau, boîtes de dialogue, boutons, menus, etc.
  Gdk	Couche bas niveau pour le système de fenêtres, événements clavier/souris, gestion des écrans et surfaces.
  Pango	Mise en forme et composition du texte, support de l’internationalisation.
  GLib et GObject	Types fondamentaux, boucle principale, système de signaux et modèle objet.
  Cairo	Moteur de rendu 2D vectoriel utilisé pour le dessin personnalisé.

  Gtk

  GTK est la bibliothèque d’interface utilisateur qui fournit les fenêtres et l’ensemble des widgets visibles. C’est elle qui permet d’assembler des containers et des contrôles comme gtk.Window, gtk.Button, gtk.Dialog ou gtk.Menu pour créer l’UI de votre application.

  Exemple d’usage typique: créer une fenêtre avec un bouton, connecter le signal clicked à une fonction Python puis afficher l’ensemble avec show_all(). Les boîtes de dialogue prêtes à l’emploi (gtk.MessageDialog, gtk.FileChooserDialog) accélèrent le prototypage.

  Gdk

  GDK sert d’abstraction bas niveau entre GTK et le système de fenêtres sous-jacent. Il gère les événements clavier et souris, les écrans et moniteurs, les curseurs, les pixmaps et le clipboard. GTK s’appuie sur GDK pour recevoir et distribuer les événements aux widgets.

  Cas concret: modifier le curseur de la souris sur une zone interactive, capter un key-press-event pour implémenter un raccourci clavier, ou récupérer la taille de l’écran afin d’adapter la mise en page.

  Pango

  Pango est la bibliothèque de mise en page textuelle et de dessin orienté internationalisation. Elle gère la césure, les polices, les scripts complexes et l’écriture de droite à gauche, afin que le texte soit correctement rendu quelle que soit la langue.

  Quand l’utiliser: dès que vous avez besoin de texte stylé ou précis, par exemple une gtk.Label avec set_markup(), des titres multi-styles, ou l’affichage de langues non latines dans une vue personnalisée.

  GLib et GObject

  GLib fournit les types fondamentaux, les utilitaires, ainsi que la boucle principale qui fait tourner l’application. GObject est la couche objet qui introduit propriétés, signaux et référencement, base du modèle événementiel de PyGTK.

  En pratique: un widget émet un signal (par exemple clicked) que vous connectez à un callback Python. Pour planifier des actions, utilisez un minuteur comme gobject.timeout_add(1000, votre_fonction) ou des tâches idle, qui s’exécutent dans la boucle GLib sans bloquer l’UI.

  Cairo

  Cairo est le moteur de rendu 2D vectoriel utilisé pour tracer lignes, courbes, textes et images avec antialiasing, y compris vers des surfaces écran ou PDF.

  Cas d’usage: créer des rendus personnalisés dans une gtk.DrawingArea. Dans PyGTK, on connecte l’événement expose-event du widget, on obtient un cairo.Context depuis widget.window.cairo_create(), puis on dessine le graphique souhaité (courbe de tendance, jauge, widget sur-mesure).

  À noter: PyGTK s’appuie aussi sur des bibliothèques connexes comme ATK pour l’accessibilité, et des outils comme Glade pour décrire l’interface en XML puis la charger dans l’application.

  Tout savoir sur PyGTK avec Liora

  Quels widgets et conteneurs sont disponibles ?

  PyGTK et son successeur PyGObject proposent un ensemble riche de widgets pour construire une GUI complète : fenêtres et boîtes de dialogue, boutons et barres d’outils, conteneurs de disposition, listes et arbres, ainsi que des champs de saisie. Ci-dessous, un tour d’horizon pratique des éléments les plus utilisés pour démarrer vite et bien.

  Fenêtres et dialogues

  La classe gtk.Window (PyGTK) ou Gtk.Window (PyGObject) représente la fenêtre principale avec barre de titre, redimensionnement et fermeture. Pour les messages rapides, gtk.MessageDialog affiche une boîte modale avec icône et boutons de réponse. Pour l’ouverture et l’enregistrement de fichiers, gtk.FileChooserDialog propose un sélecteur de fichiers prêt à l’emploi.

  Exemple d’usage courant : une Window accueille le contenu de l’application, un bouton “Ouvrir” lance un FileChooserDialog pour sélectionner un document, puis un MessageDialog confirme l’action à l’utilisateur.

  Formation Data Scientist certifiante

  Boutons et actions

  • gtk.Button : bouton classique qui émet le signal “clicked” pour déclencher une fonction callback.
  • gtk.ToggleButton : bouton à état binaire, pratique pour activer ou désactiver une option.
  • gtk.ToolButton : bouton destiné aux barres d’outils, souvent utilisé au sein de gtk.Toolbar avec une icône et une info-bulle.

  Exemple pratique : connectez “clicked” à une fonction qui lance une tâche puis met à jour une gtk.ProgressBar, tandis qu’un ToggleButton permet d’activer un “mode avancé”.

  Disposition: Box et Grid

  Les conteneurs organisent les widgets. En PyGTK, gtk.HBox et gtk.VBox empilent les éléments horizontalement ou verticalement. Avec PyGObject, Gtk.Box gère les deux orientations via une seule classe et des propriétés d’espacement et d’alignement. Pour les interfaces en grille, PyGObject propose Gtk.Grid qui place les widgets par ligne et colonne. En PyGTK, l’équivalent historique est gtk.Table pour des dispositions tabulaires.

  En résumé : Box pour des empilements simples et réactifs, Grid pour des formulaires et panneaux plus structurés avec un contrôle précis sur l’alignement et l’extension.

  Listes et arbres (TreeView)

  gtk.TreeView affiche des données tabulaires ou hiérarchiques via un modèle et des cellules de rendu. Le modèle est souvent un gtk.ListStore (liste) ou un gtk.TreeStore (arbre). Les colonnes s’appuient sur des gtk.CellRendererText, gtk.CellRendererPixbuf, etc. La sélection peut être simple ou multiple selon le mode configuré.

  Exemple : un ListStore à deux colonnes (texte et icône) alimente un TreeView. Chaque colonne dispose de son CellRenderer et peut être triable. La sélection d’une ligne met à jour un panneau de détails.

  Entrées et formulaires

  • gtk.Entry : champ de texte mono-ligne, idéal pour un nom de fichier ou une recherche, avec gestion du signal “activate”.
  • gtk.TextView : zone multi-ligne pour des notes ou du code, avec mise en forme via un buffer.
  • gtk.ComboBox : liste déroulante liée à un modèle pour choisir une option sans encombrer l’interface.
  • gtk.SpinButton : sélecteur numérique avec incréments, utile pour des quantités, tailles ou indices.

  Conseil pratique : validez les saisies côté callback et exploitez les placeholders, limites de longueur et incréments pour guider l’utilisateur. Combinez ces champs avec gtk.Scrollbar si le contenu dépasse l’espace prévu.

  Glade/GtkBuilder: comment concevoir l’UI visuellement ?

  Glade est un outil de création d’interface qui permet de dessiner vos fenêtres et widgets puis d’enregistrer le résultat dans un fichier XML au format .ui. Un outil de création d’interface dénommé Glade permet de générer une référence XML pour l’interface que la bibliothèque peut utiliser directement. Vous chargez ensuite ce fichier avec GtkBuilder depuis votre code Python, vous récupérez les widgets par leur identifiant, puis vous connectez leurs signaux à vos fonctions callback. Cette approche sépare la présentation du code, elle est idéale pour le prototypage rapide et elle est largement utilisée dans les tutoriels officiels.

  1. Concevoir l’interface dans Glade, nommer chaque widget avec un ID stable et déclarer les signaux utiles.
  2. Enregistrer le projet au format .ui (XML), à versionner avec le code.
  3. Charger le fichier dans l’application avec GtkBuilder, récupérer les widgets et connecter les signaux.
  4. Lancer la fenêtre et la boucle d’événements.

  Charger un fichier .ui avec GtkBuilder

  1. Charger: créer un GtkBuilder et appeler new_from_file pour lire le .ui.
  2. Récupérer: appeler get_object("id_du_widget") pour obtenir les widgets déclarés dans Glade.
  3. Connecter: utiliser connect_signals pour relier les noms de gestionnaires aux fonctions Python.
  4. Démarrer: afficher la fenêtre et lancer Gtk.main().

  Exemple minimal avec PyGObject et GTK 3 :

  Remarques pratiques:

  • Avec GTK 4, privilégiez Gtk.Application et window.present() plutôt que show_all().
  • Vous pouvez aussi charger l’UI en mémoire avec Gtk.Builder.new_from_string() si besoin.
  • Les noms de gestionnaires de signaux définis dans Glade doivent correspondre aux noms des méthodes ou à des entrées d’un dictionnaire passé à connect_signals.

  Quand préférer Glade au code ?

  • Prototypage rapide: créer et ajuster des écrans en quelques minutes, sans recompiler.
  • Séparation code/présentation: designers et développeurs travaillent en parallèle, le .ui vit à côté du code Python.
  • Lisibilité et maintenance: la hiérarchie de widgets est claire dans le .ui, utile pour les interfaces complexes.
  • Réutilisation et cohérence: réemployer des fragments d’interface, garder des conventions de nommage homogènes.
  • Internationalisation: étiquettes et textes sont centralisés, ce qui facilite l’extraction pour la traduction.

  Cas où écrire l’UI en code peut rester pertinent:

  • Interfaces très dynamiques générées à l’exécution, structure difficile à figer dans un .ui.
  • Micro-outils avec une seule fenêtre et peu de widgets, où le code direct est plus rapide.
  • Comportements hautement personnalisés qui nécessitent une construction programmatique fine.
  Découvrir le métier de Data Scientist

  Qu’est-ce que PyGObject ?

  Avec le lancement de la version 3 de GTK, PyGTK est remplacé par PyGObject utilisant l’Introspection GObject pour générer des bindings pour Python et d’autres langages très rapidement. Ceci permet de supprimer le délai entre les mises à jour GTK et les bindings dans différents langages.

  PyGObject fournit un wrapper à utiliser dans les programmes Python lors de l’accès aux bibliothèques GObject, un système objet notamment utilisé par GTK, GLib, GIO et GStreamer. Toute bibliothèque compatible avec l’Introspection GObject devient dynamiquement accessible depuis Python via le module gi (par exemple gi.repository.Gtk pour GTK). Dès qu’une nouvelle fonctionnalité est ajoutée dans une bibliothèque GObject, elle est immédiatement disponible en tant qu’API Python.

  PyGObject prend en charge GTK 3 et GTK 4, ce qui en fait l’alternative moderne pour les nouveaux projets Python utilisant GTK. Le wrapper PyGObject et la bibliothèque GObject sont sous licence GNU LGPL, utilisables dans des logiciels libres et propriétaires.

  Quelles différences avec PyGTK ?

  Aspect	PyGTK (bindings statiques)	PyGObject (introspection dynamique)
  Versions de GTK ciblées	GTK 2 uniquement	GTK 3 et GTK 4
  Génération des bindings	Écrits et maintenus à la main	Générés à l’exécution via gi et les métadonnées d’introspection
  Disponibilité des nouveautés	Décalage entre nouveautés GTK et bindings	Accès immédiat aux nouvelles API des bibliothèques GObject
  Compatibilité Python	Historiquement Python 2.x	Python 3.x et PyPy
  Espace de noms et import	import gtk, import gobject…	from gi.repository import Gtk, GObject, GLib, Gio
  État du projet	Figé, non maintenu pour GTK 3+	Actif, recommandé pour tout nouveau développement

  Comment installer PyGObject et utiliser gi.repository ?

  • Linux (Debian, Ubuntu et dérivées) :

    sudo apt update
    sudo apt install python3-gi python3-gi-cairo gir1.2-gtk-3.0 gir1.2-gtk-4.0

  • Linux (Fedora) :

    sudo dnf install python3-gobject gobject-introspection gtk3 gtk4

  • Linux (Arch) :

    sudo pacman -S python-gobject gobject-introspection gtk3 gtk4

  • Via pip (une fois les dépendances système installées) :

    python -m pip install PyGObject

  • Windows et macOS : installez d’abord les dépendances GTK et GObject Introspection fournies par votre système ou gestionnaire de paquets, puis utilisez pip. Consultez la documentation PyGObject/GTK pour les instructions à jour.

  Import type dans votre code :

  Comment écrire le même Hello World avec PyGObject ?

  Exemple minimal pour un nouveau projet moderne avec GTK 4 :

  Variante GTK 3 si vous devez rester sur cette version :

  Comment migrer un projet PyGTK vers PyGObject/GTK3+ ?

  1. Remplacer les imports : passez de import gtk, import gobject à from gi.repository import Gtk, GObject, GLib, Gio. Ajoutez éventuellement gi.require_version("Gtk", "3.0") ou "4.0".
  2. Adapter l’initialisation : pour GTK 3, vous pouvez conserver une boucle Gtk.main(). Pour GTK 4, adoptez Gtk.Application et ApplicationWindow avec app.run().
  3. Mettre à jour les API modifiées :
     • Conteneurs : méthodes add()/pack_start() remplacées par set_child() ou append() selon le widget en GTK 4.
     • Rendu et dessin : code drawing area basé sur Cairo peut nécessiter une mise à jour (signal draw côté GTK 3, modèle de rendu différent en GTK 4).
     • Actions et menus : Gtk.Action et UIManager obsolètes, utiliser Gio.SimpleAction et Gtk.Builder.
  4. Remplacer les widgets dépréciés par leurs équivalents récents (ex. header bars, boîtes, listes modernes).
  5. Mettre à jour les signaux et propriétés : utilisez obj.connect("signal", ...) et l’accès aux propriétés via setters ou paramètres de construction.
  6. Tester et corriger progressivement : activer les avertissements, écrire de petits tests d’interface, migrer écran par écran.
  7. Consulter les ressources officielles :
     • Tutoriel Python GTK 3 : python-gtk-3-tutorial.readthedocs.io
     • Bindings Python GTK : gtk.org/docs/language-bindings/python

  Quelles applications utilisent PyGTK ?

  

  PyGTK appartient aujourd’hui au paysage “historique” de l’écosystème GTK : il ciblait GTK+ 2 et Python 2. De très nombreux projets qui s’appuyaient sur PyGTK à l’époque GNOME 2 ont, depuis, migré vers PyGObject avec GTK 3 puis GTK 4. Cette transition s’appuie sur l’introspection GObject et des guides de portage dédiés. ([gnome.pages.gitlab.gnome.org](https://gnome.pages.gitlab.gnome.org/pygobject/guide/porting.html?utm_source=openai))

  Exemples historiques

  • Ubuntu Software Center, écrit en Python, utilisait une interface basée sur PyGTK à l’origine (puis PyGObject en fin de vie). ([en.wikipedia.org](https://en.wikipedia.org/wiki/Ubuntu_Software_Center?utm_source=openai))
  • SoundConverter, transcodeur audio pour GNOME, développé en Python avec PyGTK. ([en.wikipedia.org](https://en.wikipedia.org/wiki/GNOME_SoundConverter?utm_source=openai))
  • Deluge (client BitTorrent), dont les premières versions utilisaient GTK+ via PyGTK. ([es.wikipedia.org](https://es.wikipedia.org/wiki/Deluge_%28software%29?utm_source=openai))
  • PyChess, client d’échecs en Python, a longtemps reposé sur PyGTK avant sa réécriture moderne. ([en.wikipedia.org](https://en.wikipedia.org/wiki/PyChess?utm_source=openai))
  • Jokosher, éditeur audio multipiste en Python utilisant PyGTK et GStreamer. ([blogs.gnome.org](https://blogs.gnome.org/uraeus/2006/02/?utm_source=openai))
  • Gwibber, ancien client de micro-blogging GNOME, écrit en Python avec PyGTK jusqu’à la série 3.0. ([ru.wikipedia.org](https://ru.wikipedia.org/wiki/Gwibber?utm_source=openai))
  • Emesene, messagerie instantanée en Python/GTK. ([wiki.ubuntu.com](https://wiki.ubuntu.com/emesene?utm_source=openai))
  • Pybliographer/Pybliographic, gestion bibliographique en Python avec interface GTK. ([en.wikipedia.org](https://en.wikipedia.org/wiki/Pybliographer?utm_source=openai))

  Projets migrés et équivalents modernes

  La plupart des applications ci-dessus ont été portées vers PyGObject et GTK 3/4, souvent avec l’aide des scripts et recommandations de migration officiels. Voici quelques transitions emblématiques :

  • Deluge 2.x : interface deluge-gtk portée vers GTK 3 et PyGObject, remplacant l’ancien code PyGTK. ([deluge.readthedocs.io](https://deluge.readthedocs.io/_/downloads/en/deluge-2.0.2/pdf/?utm_source=openai))
  • PyChess ≥ 0.12 : passage à PyGObject et GTK 3 confirmé par la documentation du projet. ([en.wikipedia.org](https://en.wikipedia.org/wiki/PyChess?utm_source=openai))
  • Gramps : grande migration planifiée vers GTK 3 et l’introspection GObject, aujourd’hui distribuée avec une dépendance explicite à PyGObject. ([gramps-project.org](https://www.gramps-project.org/wiki/index.php/GEPS_029%3A_GTK3-GObject_introspection_Conversion?utm_source=openai))
  • Tryton (client desktop) : client Python/GTK désormais sur GTK 3 avec introspection, sans pygtkcompat. ([docs.tryton.org](https://docs.tryton.org/latest/client-desktop/index.html?utm_source=openai))
  • Ubiquity (installateur Ubuntu) : frontend GTK maintenu côté Python 3 avec dépendances GI pour GTK 3. ([packages.ubuntu.com](https://packages.ubuntu.com/jammy/admin/ubiquity-frontend-gtk?utm_source=openai))
  • Pitivi : éditeur vidéo GNOME ayant fait l’objet d’initiatives publiques de migration de PyGTK vers PyGObject. ([bugzilla.gnome.org](https://bugzilla.gnome.org/show_bug.cgi?id=632113&utm_source=openai))

  Pour démarrer un nouveau projet Python avec GTK aujourd’hui, il convient d’utiliser PyGObject avec GTK 3/4, la voie officielle documentée par GNOME. ([python-gtk-3-tutorial.readthedocs.io](https://python-gtk-3-tutorial.readthedocs.io/_/downloads/en/latest/pdf/?utm_source=openai))

  Dépannage: quelles erreurs courantes ?

  Beaucoup de problèmes d’installation ou d’usage viennent d’un mélange entre l’ancien PyGTK (GTK 2.x, destiné surtout à Python 2) et son successeur PyGObject pour GTK 3/4. Rappel utile du contenu ci-dessus : PyGTK a été remplacé par PyGObject basé sur l’Introspection GObject, et les bibliothèques natives fréquemment utilisées incluent Cairo, Pango, ATK, GLib et GIO.

  • Identifier votre pile cible : code historique en PyGTK/GTK2 ou code récent en PyGObject/GTK3-4.
  • Vérifier la version de Python utilisée dans votre environnement virtuel.
  • Contrôler l’import dans le code : import gtk (héritage) versus from gi.repository import Gtk (PyGObject).
  • Confirmer la présence des bibliothèques natives GTK, Cairo, Pango et des fichiers d’introspection.

  ImportError: No module named gtk

  Cette erreur apparaît quand le module Python attendu n’est pas disponible dans l’environnement courant. Les causes fréquentes : PyGTK non installé, tentative d’utiliser PyGTK avec Python 3, ou confusion entre l’ancien import gtk et l’API moderne de PyGObject.

  1. Relire l’import dans le code : si vous visez GTK 3 ou 4, remplacez import gtk par import gi; gi.require_version('Gtk','3.0') (ou '4.0') puis from gi.repository import Gtk.
  2. Vérifier la version de Python : PyGTK historique cible surtout Python 2. Pour Python 3, utilisez PyGObject.
  3. Isoler l’environnement : activez le bon venv et réinstallez les dépendances dans cet environnement plutôt que dans le système global.
  4. Écarter un conflit de nommage : supprimez tout fichier local gtk.py qui masquerait le vrai module.
  5. Installer les composants manquants : bindings PyGObject côté Python et paquets GTK correspondants côté système.

  Conflits de versions GTK/pygtk

  Les symptômes typiques : erreurs du type cannot load introspection data for Gtk, mauvaise version déclarée dans le code, ou coexistence de plusieurs runtimes GTK dans le même système.

  • Distinguer clairement les générations :
    • GTK2 + PyGTK : héritage, API import gtk, principalement pour anciens projets.
    • GTK3/GTK4 + PyGObject : moderne, API from gi.repository import Gtk, avec gi.require_version('Gtk','3.0') ou '4.0' avant l’import.
    • Linux : GI_TYPELIB_PATH (fichiers .typelib), LD_LIBRARY_PATH (bibliothèques .so), PYTHONPATH (modules Python).
    • macOS : GI_TYPELIB_PATH et DYLD_LIBRARY_PATH, plus le préfixe d’installation choisi.
    • Windows : ordre dans PATH pour pointer vers le bon dossier bin de GTK et des dépendances, éviter les doublons de versions.

    Dépendances natives manquantes (Windows/macOS)

    • Bibliothèques GTK correspondantes à votre version (GTK2 ou GTK3/4).
    • Introspection GObject : fichiers .typelib nécessaires au chargement via gi.
    • GLib et GIO : base de l’écosystème GNOME.
    • Cairo : rendu 2D utilisé par GTK.
    • Pango (+ HarfBuzz) : mise en page et rendu du texte.
    • gdk-pixbuf : chargement et transformation des images.
    • ATK (surtout pour GTK2) : accessibilité.

    Pistes d’installation pratiques : sur Windows, installez un runtime GTK cohérent avec votre Python (architecture 64 bits) et assurez-vous que son dossier bin est en tête de PATH. Sur macOS, utilisez un gestionnaire de paquets homogène pour obtenir GTK, Cairo, Pango et les fichiers d’introspection, puis définissez GI_TYPELIB_PATH si les typelibs ne sont pas détectées. Dans tous les cas, testez avec python -c "import gi; from gi.repository import Gtk; print(Gtk.MAJOR_VERSION)" pour confirmer que la bonne version est chargée.

    Se faire accompagner sur l’installation PyGTK/PyGObject

    Aller plus loin: quelles bonnes pratiques ?

    Comment styliser une interface GTK (CSS) ?

    Avec la migration vers GTK 3 et l’usage de PyGObject, la personnalisation passe par le CSS. Vous chargez des règles via un CssProvider, puis vous les appliquez avec le StyleContext sur vos widgets ou globalement sur l’affichage. Les sélecteurs utilisent les noms de widgets, des classes et des identifiants. Les thèmes système restent prioritaires, donc testez vos styles sur plusieurs environnements. Sous PyGTK historique (lié à GTK 2), le CSS n’est pas disponible, le theming reposait sur des fichiers gtkrc et des moteurs de thème. Pour un projet neuf ou une migration, privilégiez PyGObject, qui exploite l’Introspection GObject et expose immédiatement les nouveautés de GTK 3+.

    GTK et multithreading: que faut-il savoir ?

    Règle d’or: toutes les opérations UI doivent rester dans le thread principal. Exécutez vos tâches lourdes dans des threads ou des processus séparés, puis revenez au thread UI pour mettre à jour les widgets. En pratique, déclenchez ces mises à jour avec GLib.idle_add() ou GLib.timeout_add(), qui planifient une fonction à exécuter quand la boucle principale est idle. Évitez d’appeler directement des méthodes GTK depuis un worker, structurez vos callbacks pour ne transmettre que des données sérialisables, et limitez les accès partagés avec des verrous côté Python uniquement si nécessaire.

    Comment distribuer une application GTK en Python ?

    • Empaquetage autonome: PyInstaller peut regrouper votre script, les modules et les ressources (.ui Glade, icônes). Vérifiez que les dépendances GObject Introspection sont incluses à l’exécution, notamment les typelibs et bibliothèques natives nécessaires à GTK, GLib et GdkPixbuf.
    • Distribution Linux moderne: Flatpak facilite l’installation sur de nombreuses distributions. Déclarez un runtime adapté (par exemple un runtime GNOME), listez les permissions, et embarquez vos ressources. Bon choix pour publier sur Flathub et maîtriser les versions de dépendances.
    • Dépendances natives: sur Windows et macOS, installez les bibliothèques GTK et l’Introspection GObject fournies par la plateforme (MSYS2 sur Windows est souvent la voie la plus simple). Testez sur une machine vierge pour vérifier la présence des dll et typelibs. Anticipez aussi les codecs ou backends additionnels si vous utilisez GStreamer.
    • Conséquences et bonnes pratiques: prévoyez des scripts de build reproductibles, séparez logique et interface (fichiers .ui avec Glade) pour limiter la maintenance, soignez l’internationalisation et la signature éventuelle des binaires. Respectez les licences LGPL des bibliothèques utilisées, y compris lors de la redistribution.
    Approfondir PyGObject et GTK avec Liora

    Ressources et documentation utiles

    Pour aller plus loin avec les interfaces GTK en Python, privilégiez PyGObject et utilisez PyGTK uniquement comme référence historique. Voici une sélection de liens fiables et à jour pour documentations, tutoriels et dépôts.

    • PyGObject (recommandé aujourd’hui)
      • Bindings Python pour GTK sur gtk.org
      • The Python GTK+ 3 Tutorial
      • Dépôt GitLab PyGObject
      • Documentation développeur GTK
      • Wiki Python PyGtk
      • PyGTK sur PyPI
      • Tutoriel PyGTK en français (Developpez.com)
      • Dépôt GitHub pygtk (exemples historiques)
      • Glade, éditeur d’interface pour GTK

      Astuce : si vous débutez, commencez par le tutoriel “Python GTK+ 3”, puis parcourez les pages GTK et le dépôt PyGObject pour consulter l’API et des exemples concrets.

      Se former à la Data et à l'IA

      Conclusion : PyGTK, un module Python très utile pour la création de GUI

      Pendant des années, PyGTK a joué un rôle clé pour créer des interfaces graphiques en Python avec GTK+, grâce à une API orientée signaux, à l’appui de Glade et à une bonne portabilité entre Unix et Windows. Outil open-source sous licence LGPL et cross-platform, il a servi de base à de nombreuses applications et a largement facilité le prototypage rapide. Ce socle historique reste important pour comprendre son adoption et l’écosystème qui s’est construit autour de GTK 2.

      Ses limites actuelles sont néanmoins claires : PyGTK cible uniquement GTK 2 et n’évolue plus, il ne bénéficie donc pas des nouveautés apportées par GTK 3 et 4. La recommandation est d’utiliser ou de migrer vers PyGObject, basé sur l’Introspection GObject, afin d’accéder immédiatement aux bibliothèques GTK, GLib, GIO ou GStreamer, avec un support moderne de Python et des systèmes Linux, Windows et macOS. Concrètement, pour un nouveau projet ou lors d’une refonte, visez GTK 3 ou 4, remplacez progressivement les imports gtk par gi.repository, adaptez la gestion des signaux et réutilisez vos interfaces Glade au format .ui quand c’est pertinent. Conservez PyGTK uniquement pour la maintenance de projets existants, en planifiant un portage graduel vers PyGObject.

      Découvrir nos formations en Data Science