Créer un navigateur web en Python : une fenêtre, une barre d’adresse et un vrai moteur web

Pour créer un navigateur web en Python, vous pouvez assembler une interface PyQt5 et une vue QWebEngineView capable d’afficher des pages web. Vous programmez la fenêtre, la barre d’adresse et les commandes ; Qt WebEngine prend en charge le rendu. Voici une réalisation simple avec navigation au clavier, boutons précédent et suivant, actualisation et signalement des erreurs de chargement.

Ce que vous construisez : un navigateur, pas un serveur

Un navigateur est un client : il demande des ressources à un serveur, puis affiche les pages reçues. HTTP organise ces échanges ; HTML décrit la structure du contenu. Créer ce client graphique ne revient donc ni à héberger un site ni à développer son application côté serveur.

QWebEngineView appartient au module PyQt5.QtWebEngineWidgets. Ce widget repose sur Qt WebEngine, basé sur Chromium, dont Blink assure le rendu. Vous ne réécrivez donc pas un moteur HTML et JavaScript : vous intégrez un moteur existant à votre propre interface.

Cette approche convient à l’apprentissage et au prototypage d’un outil interne. Elle permet de comprendre l’articulation entre événements, adresses et affichage, sans devoir construire les composants complexes d’un navigateur moderne.

Préparer Python et installer les composants Qt

Utilisez Python 3 et, de préférence, un environnement virtuel dédié au projet. Dans un terminal, créez-le avec python -m venv .venv. Sous Windows, activez-le avec .venv\Scripts\activate ; sous Linux ou macOS, utilisez source .venv/bin/activate. Selon votre installation, la commande Python peut s’appeler python3.

Installez ensuite les dépendances avec python -m pip install PyQt5 PyQtWebEngine. La commande courante pip install PyQtWebEngine installe le composant web ; employer python -m pip aide surtout à cibler l’interpréteur qui exécutera le programme.

Si pip ne trouve aucune distribution compatible, vérifiez la version de Python, le système et l’architecture utilisés. La disponibilité des paquets dépend de cette combinaison : changer de version de Python peut être préférable à forcer une installation incompatible.

• QApplication gère l’application et sa boucle d’événements.
• QMainWindow accueille l’interface et la barre de menus QMenuBar.
• QLineEdit reçoit l’adresse ; QPushButton déclenche les actions.
• QWebEngineView affiche les pages et expose les commandes de navigation.
• QHBoxLayout et QVBoxLayout organisent les contrôles et la vue.

QWebEngineView hérite de QWidget : il s’intègre donc aux dispositions Qt comme les autres composants graphiques, sans positionner chaque élément à la main.

Assembler un exemple exécutable dans navigateur.py

Créez un fichier navigateur.py et recopiez les lignes suivantes dans l’ordre. Chaque ligne de la liste correspond à une ligne du fichier ; conservez les espaces d’indentation des méthodes. L’exemple démarre sur une page HTML locale intégrée, sans dépendre d’un site extérieur.

1. import sys
2. from PyQt5.QtCore import QUrl
3. from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QLineEdit, QPushButton
4. from PyQt5.QtWebEngineWidgets import QWebEngineView
5. class Navigateur(QMainWindow):
6. def __init__(self):
7. super().__init__()
8. self.setWindowTitle("Navigateur Python")
9. self.resize(1100, 750)
10. self.vue = QWebEngineView()
11. self.adresse = QLineEdit()
12. self.adresse.setPlaceholderText("Saisissez une adresse web")
13. barre = QHBoxLayout()
14. for texte, action in [("Précédent", self.vue.back), ("Suivant", self.vue.forward), ("Actualiser", self.vue.reload), ("Aller", self.navigate)]:
15. bouton = QPushButton(texte)
16. bouton.clicked.connect(action)
17. barre.addWidget(bouton)
18. barre.insertWidget(0, self.adresse, 1)
19. disposition = QVBoxLayout()
20. disposition.addLayout(barre)
21. disposition.addWidget(self.vue)
22. centre = QWidget()
23. centre.setLayout(disposition)
24. self.setCentralWidget(centre)
25. self.menuBar().addMenu("Fichier").addAction("Quitter", self.close)
26. self.adresse.returnPressed.connect(self.navigate)
27. self.vue.urlChanged.connect(self.actualiser_adresse)
28. self.vue.loadFinished.connect(self.fin_chargement)
29. self.vue.setHtml("<h2>Navigateur prêt</h2><p>Saisissez une adresse pour commencer.</p>")
30. def navigate(self):
31. texte = self.adresse.text().strip()
32. if not texte:
33. return
34. if "://" not in texte:
35. texte = "https://" + texte
36. url = QUrl(texte)
37. if url.scheme() not in ("http", "https") or not url.host():
38. self.statusBar().showMessage("Adresse HTTP ou HTTPS attendue.")
39. return
40. self.statusBar().showMessage("Chargement…")
41. self.vue.setUrl(url)
42. def actualiser_adresse(self, url):
43. if url.scheme() in ("http", "https"):
44. self.adresse.setText(url.toString())
45. def fin_chargement(self, reussi):
46. self.statusBar().showMessage("Page chargée." if reussi else "Chargement impossible ou interrompu.")
47. if __name__ == "__main__":
48. app = QApplication(sys.argv)
49. fenetre = Navigateur()
50. fenetre.show()
51. sys.exit(app.exec_())

Lancez le fichier avec python navigateur.py. La fenêtre doit présenter les contrôles en haut et la page de bienvenue dessous. Saisissez ensuite l’adresse d’un site connu et validez avec Entrée ou le bouton Aller.

Comprendre le trajet d’une adresse jusqu’à la page

La méthode navigate() récupère la saisie de QLineEdit et retire les espaces superflus. Si aucun protocole n’est présent, elle ajoute https://. Un serveur local utilisant HTTP nécessite donc une adresse explicitement préfixée par http://. Cette saisie n’est pas une barre de recherche : écrire quelques mots ne lance pas un moteur de recherche.

Après une vérification élémentaire du protocole et de l’hôte, setUrl() reçoit un objet QUrl et déclenche le chargement. Cette vérification ne garantit ni l’existence du domaine ni son accessibilité. Le signal loadFinished indique ensuite si le chargement a réussi, sans fournir ici un diagnostic réseau détaillé.

Pensez aux événements comme à un courant qui circule dans l’interface : la saisie déclenche une demande, mais la page peut ensuite rediriger vers une autre adresse. Relier urlChanged au champ de saisie ferme cette boucle de retour. Sans cette connexion, la barre pourrait afficher l’adresse demandée plutôt que celle réellement visitée, un décalage gênant pour comprendre une redirection ou vérifier le domaine affiché.

Les boutons précédent, suivant et actualiser appellent directement les méthodes de la vue. La barre de menus est créée par menuBar(), qui fournit une QMenuBar. Enfin, app.exec_() maintient la boucle d’événements : sans elle, la fenêtre ne resterait pas interactive.

Tester le prototype et fixer ses limites

Validez le comportement avant d’ajouter des fonctionnalités. Une progression simple permet de distinguer un problème d’interface d’un problème réseau :

• Vérifiez l’affichage de la page de bienvenue.
• Ouvrez une adresse HTTPS avec Entrée, puis avec Aller.
• Suivez un lien et contrôlez la mise à jour de l’adresse.
• Testez précédent, suivant et actualiser.
• Essayez un domaine inexistant et observez le message d’échec.

Pour un essai local, placez un fichier index.html dans un dossier de test, puis lancez depuis ce dossier python -m http.server 8000 --bind 127.0.0.1. Saisissez http://127.0.0.1:8000 dans votre navigateur. Le serveur partage le répertoire courant ; choisissez donc un dossier sans documents sensibles. Arrêtez-le avec Ctrl+C. Si le port est déjà occupé, choisissez-en un autre.

Une erreur ModuleNotFoundError invite à vérifier l’environnement Python et les dépendances. Pour une page inaccessible, contrôlez d’abord l’adresse, la connexion et le protocole. Ne contournez pas les erreurs de certificat pour obtenir artificiellement un chargement réussi.

Ce prototype ne propose pas d’onglets, de favoris, de gestionnaire de téléchargements ni d’interface d’historique persistant. Intégrer Chromium ne suffit pas non plus à garantir la sécurité d’un navigateur maintenu. Gardez les dépendances à jour et réservez d’abord cette application à l’apprentissage ou à des usages maîtrisés, plutôt qu’à la consultation de comptes sensibles.