- À propos de la création d'un script d'informations système avec le module platform
- Préparer le script et importer le module platform
- Récupérer le système d'exploitation et les informations de la machine
- Obtenir l'architecture et les informations sur le processeur
- Récupérer la version et l'implémentation de Python
- Regrouper les informations système dans un dictionnaire
- Créer une fonction réutilisable de collecte des informations
- Construire l'application complète d'informations système
- Enregistrer le rapport système dans un fichier
- À retenir !
1. À propos de la création d'un script d'informations système avec le module platform
Python permet de récupérer facilement différentes informations concernant l'ordinateur sur lequel un programme est exécuté. Le module standard platform fournit pour cela plusieurs fonctions permettant d'interroger le système d'exploitation, la machine, l'architecture, le processeur et la version de Python.
Dans ce tutoriel, nous allons réunir ces différentes fonctionnalités afin de réaliser une petite application d'informations système. Elle affichera notamment le système d'exploitation, sa version, le nom de la machine, son architecture, son processeur et les principales informations concernant Python.
Avant de construire l'application complète, voici un premier exemple très simple permettant d'obtenir le nom du système d'exploitation.
1 2 3 | import platform print("Système d'exploitation :", platform.system()) |
Sortie possible :
1 | Système d'exploitation : Windows |
La sortie dépend naturellement de l'ordinateur utilisé. Sous Linux, la valeur retournée sera généralement "Linux", tandis que sous macOS, platform.system() retourne généralement "Darwin".
2. Préparer le script et importer le module platform
Le module platform appartient à la bibliothèque standard de Python. Il n'est donc pas nécessaire de l'installer avec pip. L'instruction import platform suffit pour accéder à ses fonctions.
Commençons notre application par un petit en-tête permettant de vérifier que le module est correctement importé.
1 2 3 4 5 6 | import platform print("=" * 45) print(" INFORMATIONS DU SYSTÈME") print("=" * 45) print("Module platform chargé avec succès.") |
Sortie :
1 2 3 4 | ============================================= INFORMATIONS DU SYSTÈME ============================================= Module platform chargé avec succès. |
Nous pouvons également utiliser platform.platform() pour obtenir immédiatement une chaîne donnant un résumé général de la plateforme.
1 2 3 4 5 | import platform resume = platform.platform() print("Résumé :", resume) |
Sortie possible :
1 | Résumé : Windows-10-10.0.19045-SP0 |
Le contenu exact de cette chaîne dépend du système et de sa configuration. Notre application va cependant aller plus loin en récupérant séparément chaque information importante.
3. Récupérer le système d'exploitation et les informations de la machine
La fonction platform.uname() permet de récupérer en une seule opération plusieurs informations sur le système. Son résultat possède notamment les attributs system, node, release, version, machine et processor.
Nous pouvons utiliser ces attributs pour afficher le système d'exploitation, le nom de la machine, la release et la version du système.
1 2 3 4 5 6 7 8 | import platform infos = platform.uname() print("Système :", infos.system) print("Nom de la machine :", infos.node) print("Release :", infos.release) print("Version :", infos.version) |
Sortie possible :
1 2 3 4 | Système : Windows Nom de la machine : MON-PC Release : 10 Version : 10.0.19045 |
Le nom retourné par node correspond au nom de la machine sur le réseau. Il varie donc d'un ordinateur à un autre.
Nous pouvons également détecter explicitement Windows, Linux ou macOS afin d'afficher un nom plus convivial.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import platform systeme = platform.system() if systeme == "Windows": nom_systeme = "Windows" elif systeme == "Linux": nom_systeme = "Linux" elif systeme == "Darwin": nom_systeme = "macOS" else: nom_systeme = systeme print("Système détecté :", nom_systeme) |
Sortie possible sous macOS :
1 | Système détecté : macOS |
Cette conversion est utile parce que platform.system() retourne "Darwin" sous macOS.
4. Obtenir l'architecture et les informations sur le processeur
Notre application doit également fournir des informations sur la partie matérielle. La fonction platform.machine() retourne le type de machine ou l'architecture matérielle rapportée par le système.
1 2 3 | import platform print("Machine :", platform.machine()) |
Sortie possible :
1 | Machine : AMD64 |
La fonction platform.architecture() retourne généralement un tuple contenant la taille des mots de l'exécutable Python, par exemple "64bit", ainsi qu'une information sur son format de liaison.
1 2 3 4 5 6 7 | import platform architecture = platform.architecture() print("Architecture :", architecture) print("Nombre de bits :", architecture[0]) print("Format :", architecture[1]) |
Sortie possible sous Windows :
1 2 3 | Architecture : ('64bit', 'WindowsPE') Nombre de bits : 64bit Format : WindowsPE |
Il faut distinguer platform.machine() et platform.architecture(). La première renseigne sur le type de machine rapporté par le système, tandis que la seconde renseigne principalement sur l'architecture de l'exécutable Python.
La fonction platform.processor() peut fournir une information sur le processeur.
1 2 3 4 5 | import platform processeur = platform.processor() print("Processeur :", processeur) |
Sortie possible :
1 | Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel |
La valeur retournée par platform.processor() dépend fortement du système. Elle peut être détaillée sur certaines machines et vide sur d'autres. Il ne faut donc pas considérer cette fonction comme une méthode universelle permettant d'obtenir systématiquement le nom commercial exact du processeur.
5. Récupérer la version et l'implémentation de Python
Une application de diagnostic peut également afficher des informations concernant l'environnement Python. La fonction platform.python_version() retourne la version de Python sous forme de chaîne.
1 2 3 | import platform print("Version de Python :", platform.python_version()) |
Sortie possible :
1 | Version de Python : 3.13.7 |
Pour connaître l'implémentation de Python, nous pouvons utiliser platform.python_implementation(). La valeur la plus courante est CPython.
1 2 3 4 | import platform print("Version :", platform.python_version()) print("Implémentation :", platform.python_implementation()) |
Sortie possible :
1 2 | Version : 3.13.7 Implémentation : CPython |
La fonction platform.python_compiler() permet également d'obtenir une chaîne décrivant le compilateur utilisé pour construire l'interpréteur Python.
1 2 3 4 5 | import platform print("Python :", platform.python_version()) print("Implémentation :", platform.python_implementation()) print("Compilateur :", platform.python_compiler()) |
Sortie possible :
1 2 3 | Python : 3.13.7 Implémentation : CPython Compilateur : MSC v.1944 64 bit (AMD64) |
Ces informations sont particulièrement utiles lorsqu'un programme rencontre un problème dépendant de la version de Python ou de son environnement d'exécution.
6. Regrouper les informations système dans un dictionnaire
Maintenant que nous savons récupérer les différentes informations, nous pouvons les regrouper dans un dictionnaire Python. Cette structure facilite leur affichage, leur traitement et leur éventuel enregistrement dans un fichier.
Le programme suivant construit un dictionnaire contenant les principales informations de notre application.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | import platform infos = platform.uname() systeme = { "Système": infos.system, "Nom de la machine": infos.node, "Release": infos.release, "Version système": infos.version, "Machine": infos.machine, "Architecture": platform.architecture()[0], "Processeur": infos.processor, "Version Python": platform.python_version() } for nom, valeur in systeme.items(): print(f"{nom} : {valeur}") |
Sortie possible :
1 2 3 4 5 6 7 8 | Système : Windows Nom de la machine : MON-PC Release : 10 Version système : 10.0.19045 Machine : AMD64 Architecture : 64bit Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Version Python : 3.13.7 |
Le dictionnaire permet de centraliser toutes les informations dans une seule variable. Nous pouvons facilement lui ajouter d'autres données.
Par exemple, ajoutons l'implémentation et le compilateur de Python.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import platform informations = { "Plateforme": platform.platform(), "Système": platform.system(), "Machine": platform.machine(), "Architecture": platform.architecture()[0], "Processeur": platform.processor(), "Python": platform.python_version(), "Implémentation": platform.python_implementation(), "Compilateur": platform.python_compiler() } for cle, valeur in informations.items(): print(f"{cle} : {valeur}") |
Sortie possible :
1 2 3 4 5 6 7 8 | Plateforme : Windows-10-10.0.19045-SP0 Système : Windows Machine : AMD64 Architecture : 64bit Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Python : 3.13.7 Implémentation : CPython Compilateur : MSC v.1944 64 bit (AMD64) |
7. Créer une fonction réutilisable de collecte des informations
Pour rendre notre application mieux organisée, nous pouvons placer la collecte des données dans une fonction. Cette fonction retourne un dictionnaire contenant toutes les informations nécessaires.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | import platform def obtenir_informations_systeme(): infos = platform.uname() if infos.system == "Darwin": nom_systeme = "macOS" else: nom_systeme = infos.system return { "Système": nom_systeme, "Nom de la machine": infos.node, "Release": infos.release, "Version système": infos.version, "Machine": infos.machine, "Architecture": platform.architecture()[0], "Processeur": infos.processor, "Version Python": platform.python_version() } informations = obtenir_informations_systeme() for nom, valeur in informations.items(): print(f"{nom} : {valeur}") |
Sortie possible :
1 2 3 4 5 6 7 8 | Système : Windows Nom de la machine : MON-PC Release : 10 Version système : 10.0.19045 Machine : AMD64 Architecture : 64bit Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Version Python : 3.13.7 |
La fonction obtenir_informations_systeme() peut maintenant être appelée depuis différentes parties du programme sans répéter les instructions de collecte.
Nous pouvons également créer une seconde fonction uniquement chargée de l'affichage.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | def afficher_informations(informations): print("=" * 50) print(" INFORMATIONS DU SYSTÈME") print("=" * 50) for nom, valeur in informations.items(): print(f"{nom:20} : {valeur}") print("=" * 50) donnees = { "Système": "Windows", "Machine": "AMD64", "Architecture": "64bit", "Python": "3.13.7" } afficher_informations(donnees) |
Sortie :
1 2 3 4 5 6 7 8 | ================================================== INFORMATIONS DU SYSTÈME ================================================== Système : Windows Machine : AMD64 Architecture : 64bit Python : 3.13.7 ================================================== |
Cette séparation entre collecte des données et affichage rend le programme plus facile à modifier et à réutiliser.
8. Construire l'application complète d'informations système
Nous pouvons maintenant réunir les éléments précédents afin de créer notre application complète d'informations système. Le programme collecte les données avec une fonction puis les affiche sous une forme lisible.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 | import platform def obtenir_informations_systeme(): infos = platform.uname() if infos.system == "Darwin": nom_systeme = "macOS" else: nom_systeme = infos.system architecture = platform.architecture() return { "Système": nom_systeme, "Nom de la machine": infos.node, "Release": infos.release, "Version système": infos.version, "Machine": infos.machine, "Architecture": architecture[0], "Format": architecture[1], "Processeur": infos.processor or "Non disponible", "Version Python": platform.python_version(), "Implémentation Python": platform.python_implementation(), "Compilateur Python": platform.python_compiler() } def afficher_informations(informations): print("=" * 60) print(" INFORMATIONS DU SYSTÈME") print("=" * 60) for nom, valeur in informations.items(): print(f"{nom:22} : {valeur}") print("=" * 60) informations = obtenir_informations_systeme() afficher_informations(informations) |
Sortie possible :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | ============================================================ INFORMATIONS DU SYSTÈME ============================================================ Système : Windows Nom de la machine : MON-PC Release : 10 Version système : 10.0.19045 Machine : AMD64 Architecture : 64bit Format : WindowsPE Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Version Python : 3.13.7 Implémentation Python : CPython Compilateur Python : MSC v.1944 64 bit (AMD64) ============================================================ |
L'expression infos.processor or "Non disponible" permet d'afficher un message explicite lorsque le système ne fournit aucune information sur le processeur.
Nous pouvons également placer le lancement de l'application dans le bloc if __name__ == "__main__". Cette organisation est recommandée lorsqu'un fichier Python peut être exécuté directement mais également importé comme module dans un autre programme.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | import platform def obtenir_informations_systeme(): infos = platform.uname() return { "Système": "macOS" if infos.system == "Darwin" else infos.system, "Machine": infos.machine, "Architecture": platform.architecture()[0], "Processeur": infos.processor or "Non disponible", "Python": platform.python_version() } def afficher_informations(informations): print("=== INFORMATIONS SYSTÈME ===") for nom, valeur in informations.items(): print(f"{nom} : {valeur}") if __name__ == "__main__": informations = obtenir_informations_systeme() afficher_informations(informations) |
Sortie possible :
1 2 3 4 5 6 | === INFORMATIONS SYSTÈME === Système : Windows Machine : AMD64 Architecture : 64bit Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Python : 3.13.7 |
9. Enregistrer le rapport système dans un fichier
Une petite application de diagnostic devient encore plus utile lorsqu'elle permet d'enregistrer les informations système dans un fichier. Le rapport peut ensuite être conservé ou transmis pour analyser un problème technique.
Le programme suivant collecte les principales informations puis les écrit dans un fichier nommé systeme.txt.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | import platform infos = platform.uname() informations = { "Système": "macOS" if infos.system == "Darwin" else infos.system, "Nom de la machine": infos.node, "Release": infos.release, "Version système": infos.version, "Machine": infos.machine, "Architecture": platform.architecture()[0], "Processeur": infos.processor or "Non disponible", "Version Python": platform.python_version() } with open("systeme.txt", "w", encoding="utf-8") as fichier: for nom, valeur in informations.items(): fichier.write(f"{nom} : {valeur}\n") print("Rapport enregistré dans systeme.txt.") |
Sortie :
1 | Rapport enregistré dans systeme.txt. |
Le fichier créé contient alors les informations système collectées lors de l'exécution.
1 2 3 4 5 6 7 8 | Système : Windows Nom de la machine : MON-PC Release : 10 Version système : 10.0.19045 Machine : AMD64 Architecture : 64bit Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Version Python : 3.13.7 |
Sortie :
1 | Le rapport contient les principales informations sur le système et l'environnement Python. |
Nous pouvons enfin réunir l'affichage et l'enregistrement dans une application complète disposant de fonctions distinctes.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 | import platform def obtenir_informations(): infos = platform.uname() return { "Système": "macOS" if infos.system == "Darwin" else infos.system, "Machine": infos.machine, "Architecture": platform.architecture()[0], "Processeur": infos.processor or "Non disponible", "Python": platform.python_version() } def afficher(informations): for nom, valeur in informations.items(): print(f"{nom} : {valeur}") def enregistrer(informations, nom_fichier): with open(nom_fichier, "w", encoding="utf-8") as fichier: for nom, valeur in informations.items(): fichier.write(f"{nom} : {valeur}\n") if __name__ == "__main__": informations = obtenir_informations() afficher(informations) enregistrer(informations, "systeme.txt") print("Rapport enregistré avec succès.") |
Sortie possible :
1 2 3 4 5 6 | Système : Windows Machine : AMD64 Architecture : 64bit Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Python : 3.13.7 Rapport enregistré avec succès. |
Notre petite application possède maintenant trois responsabilités clairement séparées : collecter les informations, les afficher et les enregistrer.
10. À retenir !
Le module platform permet de réaliser facilement une application d'informations système en Python sans installer de bibliothèque externe.
- platform.system() permet d'obtenir le nom du système d'exploitation.
- platform.uname() regroupe plusieurs informations sur le système et la machine.
- platform.machine() retourne le type de machine ou l'architecture matérielle rapportée par le système.
- platform.architecture() fournit principalement des informations sur l'architecture de l'exécutable Python.
- platform.processor() fournit une information sur le processeur lorsqu'elle est disponible.
- platform.python_version() retourne la version de Python.
- platform.python_implementation() indique l'implémentation Python utilisée, par exemple CPython.
- platform.python_compiler() donne des informations sur le compilateur utilisé pour construire Python.
- Sous macOS, platform.system() retourne généralement "Darwin".
- Un dictionnaire permet de regrouper proprement les informations collectées.
- Des fonctions permettent de séparer la collecte, l'affichage et l'enregistrement des informations.
- Le bloc if __name__ == "__main__" permet de distinguer l'exécution directe du script de son importation comme module.
- Les résultats des fonctions du module platform dépendent du système et certaines informations peuvent être absentes.
Le programme suivant constitue une version compacte de l'application regroupant les cinq informations essentielles demandées : système d'exploitation, machine, architecture, processeur et version de Python.
1 2 3 4 5 6 7 8 9 10 11 12 | import platform infos = platform.uname() systeme = "macOS" if infos.system == "Darwin" else infos.system print("=== INFORMATIONS SYSTÈME ===") print("Système :", systeme) print("Machine :", infos.machine) print("Architecture :", platform.architecture()[0]) print("Processeur :", infos.processor or "Non disponible") print("Version Python :", platform.python_version()) |
Sortie possible :
1 2 3 4 5 6 | === INFORMATIONS SYSTÈME === Système : Windows Machine : AMD64 Architecture : 64bit Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Version Python : 3.13.7 |
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
