- À propos des modules platform, sys et os en Python
- Comparer platform.system(), sys.platform et os.name
- Obtenir des informations détaillées avec le module platform
- Obtenir des informations sur Python avec le module sys
- Obtenir des informations sur le système avec le module os
- Détecter Windows, Linux et macOS avec platform, sys et os
- Comprendre quand utiliser platform, sys ou os
- Combiner platform, sys et os dans un même programme
- Créer un script complet de diagnostic système
- À retenir !
1. À propos des modules platform, sys et os en Python
Python possède plusieurs modules standards capables de fournir des informations sur l'environnement dans lequel un programme est exécuté. Parmi les plus importants figurent platform, sys et os. Ces trois modules peuvent sembler similaires lorsqu'il s'agit d'identifier le système, mais ils n'ont pas exactement le même rôle.
Le module platform est spécialisé dans l'identification de la plateforme : système d'exploitation, version du système, machine, architecture, processeur ou encore version et implémentation de Python. Le module sys fournit principalement des informations concernant l'interpréteur Python et son environnement d'exécution. Le module os fournit quant à lui une interface avec le système d'exploitation et permet notamment de travailler avec les fichiers, les dossiers, les variables d'environnement et différents services du système.
Ces trois modules appartiennent à la bibliothèque standard de Python. Aucune installation avec pip n'est donc nécessaire.
1 2 3 4 5 | import platform import sys import os print("Les modules platform, sys et os sont disponibles.") |
Sortie :
1 | Les modules platform, sys et os sont disponibles. |
Pour comprendre immédiatement leur différence, nous pouvons afficher trois informations représentatives : platform.system(), sys.platform et os.name.
1 2 3 4 5 6 7 | import platform import sys import os print("platform.system() :", platform.system()) print("sys.platform :", sys.platform) print("os.name :", os.name) |
Sortie possible sous Windows :
1 2 3 | platform.system() : Windows sys.platform : win32 os.name : nt |
Les trois résultats désignent ici le même environnement, mais ils utilisent des niveaux d'information et des conventions de nommage différents.
2. Comparer platform.system(), sys.platform et os.name
Les éléments platform.system(), sys.platform et os.name permettent tous d'obtenir une information liée à la plateforme, mais ils ne retournent pas les mêmes valeurs.
platform.system() retourne un nom relativement lisible du système d'exploitation. Il s'agit d'une fonction qui doit donc être appelée avec des parenthèses.
1 2 3 | import platform print(platform.system()) |
Sortie possible sous Windows :
1 | Windows |
sys.platform est un attribut du module sys. Il fournit un identifiant de plateforme utilisé par Python.
1 2 3 | import sys print(sys.platform) |
Sortie possible sous Windows :
1 | win32 |
Le nom win32 peut également être retourné lorsqu'un Python 64 bits fonctionne sous Windows 64 bits. Il ne faut donc pas utiliser cette valeur pour déterminer si Python fonctionne en 32 ou 64 bits.
os.name fournit une identification plus générale de la famille du système d'exploitation.
1 2 3 | import os print(os.name) |
Sortie possible sous Windows :
1 | nt |
La comparaison devient particulièrement claire lorsque nous observons les valeurs courantes sous les trois principaux systèmes.
| Système | platform.system() | sys.platform | os.name |
|---|---|---|---|
| Windows | Windows | win32 | nt |
| Linux | Linux | linux | posix |
| macOS | Darwin | darwin | posix |
Cette comparaison montre que os.name ne permet pas, à lui seul, de distinguer Linux de macOS puisqu'ils appartiennent généralement tous les deux à la famille posix. Pour identifier précisément ces systèmes, platform.system() ou sys.platform sont plus adaptés.
3. Obtenir des informations détaillées avec le module platform
Le module platform est le plus spécialisé des trois lorsqu'il s'agit d'obtenir des informations descriptives sur le système. Il fournit plusieurs fonctions consacrées au système d'exploitation, à la machine et à l'environnement Python.
Le programme suivant utilise plusieurs fonctions importantes du module platform.
1 2 3 4 5 6 7 8 | import platform print("Système :", platform.system()) print("Release :", platform.release()) print("Version :", platform.version()) print("Machine :", platform.machine()) print("Processeur :", platform.processor()) print("Plateforme :", platform.platform()) |
Sortie possible sous Windows :
1 2 3 4 5 6 | Système : Windows Release : 10 Version : 10.0.19045 Machine : AMD64 Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Plateforme : Windows-10-10.0.19045-SP0 |
La fonction platform.uname() permet également de regrouper plusieurs informations dans un même résultat.
1 2 3 4 5 6 7 8 9 10 | import platform infos = platform.uname() print("Système :", infos.system) print("Machine réseau :", infos.node) print("Release :", infos.release) print("Version :", infos.version) print("Machine :", infos.machine) print("Processeur :", infos.processor) |
Sortie possible :
1 2 3 4 5 6 | Système : Windows Machine réseau : MON-PC Release : 10 Version : 10.0.19045 Machine : AMD64 Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel |
Le module platform peut également fournir des informations concernant Python lui-même.
1 2 3 4 5 | import platform print("Version Python :", platform.python_version()) print("Implémentation :", platform.python_implementation()) print("Compilateur :", platform.python_compiler()) |
Sortie possible :
1 2 3 | Version Python : 3.13.7 Implémentation : CPython Compilateur : MSC v.1944 64 bit (AMD64) |
Le module platform constitue donc un excellent choix lorsqu'un programme doit produire une fiche descriptive du système ou un rapport de diagnostic.
4. Obtenir des informations sur Python avec le module sys
Le module sys est davantage orienté vers l'interpréteur Python et son environnement d'exécution. Il contient notamment la version de Python, l'identifiant de la plateforme, le chemin de l'interpréteur et différentes informations internes.
L'attribut sys.version fournit une chaîne détaillée décrivant la version de Python utilisée.
1 2 3 | import sys print(sys.version) |
Sortie possible :
1 | 3.13.7 (main, Aug 14 2026, 12:00:00) [MSC v.1944 64 bit (AMD64)] |
Pour effectuer des comparaisons de versions dans un programme, il est généralement préférable d'utiliser sys.version_info, qui fournit les composantes de la version sous une forme structurée.
1 2 3 4 5 6 | import sys print("Version complète :", sys.version_info) print("Version majeure :", sys.version_info.major) print("Version mineure :", sys.version_info.minor) print("Micro-version :", sys.version_info.micro) |
Sortie possible :
1 2 3 4 | Version complète : sys.version_info(major=3, minor=13, micro=7, releaselevel='final', serial=0) Version majeure : 3 Version mineure : 13 Micro-version : 7 |
L'attribut sys.platform permet d'identifier la plateforme sur laquelle Python est exécuté.
1 2 3 | import sys print("Plateforme Python :", sys.platform) |
Sortie possible sous Linux :
1 | Plateforme Python : linux |
Enfin, sys.executable permet d'obtenir le chemin de l'interpréteur Python utilisé pour exécuter le programme.
1 2 3 | import sys print("Interpréteur Python :", sys.executable) |
Sortie possible sous Windows :
1 | Interpréteur Python : C:\Python313\python.exe |
Le module sys est donc particulièrement utile lorsqu'un programme doit connaître les caractéristiques de l'interpréteur Python plutôt que celles du système d'exploitation en général.
5. Obtenir des informations sur le système avec le module os
Le module os possède un objectif plus large : fournir une interface portable avec différentes fonctionnalités du système d'exploitation. Il permet notamment de manipuler des fichiers et des répertoires, d'accéder aux variables d'environnement et d'obtenir certaines informations relatives aux processus.
L'attribut os.name fournit le nom de la famille du système.
1 2 3 | import os print("Famille du système :", os.name) |
Sortie possible sous Windows :
1 | Famille du système : nt |
Sous Linux et macOS, la valeur courante est généralement "posix".
1 2 3 | import os print("Famille du système :", os.name) |
Sortie possible sous Linux :
1 | Famille du système : posix |
Le module os permet également de connaître le répertoire de travail courant avec os.getcwd().
1 2 3 | import os print("Répertoire courant :", os.getcwd()) |
Sortie possible :
1 | Répertoire courant : C:\Users\Utilisateur\Documents |
La variable os.environ donne accès aux variables d'environnement. La méthode get() permet de récupérer une variable sans provoquer d'erreur lorsqu'elle n'existe pas.
1 2 3 | import os print("PATH :", os.environ.get("PATH")) |
Sortie possible :
1 | PATH : C:\Windows\system32;C:\Windows;C:\Python313;... |
Le module os peut également fournir l'identifiant du processus courant avec os.getpid().
1 2 3 | import os print("PID du programme :", os.getpid()) |
Sortie possible :
1 | PID du programme : 8240 |
Contrairement au module platform, os n'a donc pas pour objectif principal de produire une description détaillée de la plateforme. Il sert surtout à interagir avec le système d'exploitation.
6. Détecter Windows, Linux et macOS avec platform, sys et os
Les trois modules peuvent intervenir dans la détection du système, mais platform.system() et sys.platform permettent une distinction plus précise entre Windows, Linux et macOS que os.name.
Détection avec platform.system()
Avec platform.system(), Windows est identifié par "Windows", Linux par "Linux" et macOS par "Darwin".
1 2 3 4 5 6 7 8 9 10 11 12 | import platform systeme = platform.system() if systeme == "Windows": print("Windows détecté") elif systeme == "Linux": print("Linux détecté") elif systeme == "Darwin": print("macOS détecté") else: print("Autre système :", systeme) |
Sortie possible sous Windows :
1 | Windows détecté |
Détection avec sys.platform
Avec sys.platform, les identifiants courants sont "win32", "linux" et "darwin". La méthode startswith() peut notamment être utilisée pour Windows afin de rendre le test explicite.
1 2 3 4 5 6 7 8 9 10 | import sys if sys.platform.startswith("win"): print("Windows détecté") elif sys.platform.startswith("linux"): print("Linux détecté") elif sys.platform == "darwin": print("macOS détecté") else: print("Autre plateforme :", sys.platform) |
Sortie possible sous Linux :
1 | Linux détecté |
Détection avec os.name
Avec os.name, nous pouvons facilement distinguer Windows des systèmes de type POSIX. En revanche, la valeur "posix" ne permet pas à elle seule de savoir s'il s'agit de Linux ou de macOS.
1 2 3 4 5 6 7 8 | import os if os.name == "nt": print("Système de la famille Windows") elif os.name == "posix": print("Système de type POSIX") else: print("Autre famille :", os.name) |
Sortie possible sous macOS :
1 | Système de type POSIX |
Pour une détection lisible de Windows, Linux et macOS, platform.system() constitue généralement le choix le plus simple.
7. Comprendre quand utiliser platform, sys ou os
Le choix entre platform, sys et os dépend principalement du type d'information recherché. Ces modules sont complémentaires plutôt que concurrents.
| Besoin | Module conseillé | Exemple |
|---|---|---|
| Nom lisible du système | platform | platform.system() |
| Version du système | platform | platform.release() |
| Machine | platform | platform.machine() |
| Processeur | platform | platform.processor() |
| Architecture de l'exécutable | platform | platform.architecture() |
| Identifiant de plateforme Python | sys | sys.platform |
| Version détaillée de Python | sys | sys.version_info |
| Chemin de l'interpréteur Python | sys | sys.executable |
| Famille du système | os | os.name |
| Répertoire courant | os | os.getcwd() |
| Variables d'environnement | os | os.environ |
| Identifiant du processus | os | os.getpid() |
Pour illustrer cette complémentarité, le programme suivant utilise chaque module pour ce qu'il décrit le mieux.
1 2 3 4 5 6 7 8 9 10 | import platform import sys import os print("Système :", platform.system()) print("Machine :", platform.machine()) print("Plateforme Python :", sys.platform) print("Version Python :", sys.version_info[:3]) print("Famille OS :", os.name) print("Répertoire courant :", os.getcwd()) |
Sortie possible :
1 2 3 4 5 6 | Système : Windows Machine : AMD64 Plateforme Python : win32 Version Python : (3, 13, 7) Famille OS : nt Répertoire courant : C:\Users\Utilisateur\Documents |
Nous pouvons donc retenir une règle pratique : platform décrit principalement la plateforme, sys décrit principalement l'environnement d'exécution Python et os fournit des services permettant d'interagir avec le système d'exploitation.
8. Combiner platform, sys et os dans un même programme
Dans une application de diagnostic, il peut être intéressant de combiner les trois modules afin d'obtenir une vue plus complète de l'environnement d'exécution.
Le programme suivant rassemble les principales informations dans un dictionnaire Python.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import platform import sys import os informations = { "Système": platform.system(), "Release": platform.release(), "Machine": platform.machine(), "Processeur": platform.processor() or "Non disponible", "Plateforme Python": sys.platform, "Version Python": platform.python_version(), "Interpréteur": sys.executable, "Famille OS": os.name, "Répertoire courant": os.getcwd(), "PID": os.getpid() } for nom, valeur in informations.items(): print(f"{nom} : {valeur}") |
Sortie possible :
1 2 3 4 5 6 7 8 9 10 | Système : Windows Release : 10 Machine : AMD64 Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Plateforme Python : win32 Version Python : 3.13.7 Interpréteur : C:\Python313\python.exe Famille OS : nt Répertoire courant : C:\Users\Utilisateur\Documents PID : 8240 |
Cette approche permet de profiter des informations spécialisées de chaque module sans chercher à utiliser un seul module pour tous les besoins.
Nous pouvons également afficher directement les trois identifiants du système afin de voir leurs différences.
1 2 3 4 5 6 7 8 9 | import platform import sys import os print("Identification du système") print("-------------------------") print("platform.system() :", platform.system()) print("sys.platform :", sys.platform) print("os.name :", os.name) |
Sortie possible sous macOS :
1 2 3 4 5 | Identification du système ------------------------- platform.system() : Darwin sys.platform : darwin os.name : posix |
Cet exemple montre clairement que ces trois informations ne sont pas interchangeables, même si elles concernent toutes la plateforme d'exécution.
9. Créer un script complet de diagnostic système
Nous pouvons maintenant créer un petit script de diagnostic système combinant platform, sys et os. Une première fonction collecte les informations et une seconde les affiche.
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 39 40 41 | import platform import sys import os def obtenir_informations(): systeme = platform.system() if systeme == "Darwin": nom_systeme = "macOS" else: nom_systeme = systeme return { "Système": nom_systeme, "Release": platform.release(), "Version système": platform.version(), "Machine": platform.machine(), "Architecture": platform.architecture()[0], "Processeur": platform.processor() or "Non disponible", "Plateforme Python": sys.platform, "Version Python": platform.python_version(), "Implémentation": platform.python_implementation(), "Interpréteur": sys.executable, "Famille OS": os.name, "Répertoire courant": os.getcwd(), "PID": os.getpid() } def afficher_informations(informations): print("=" * 60) print(" DIAGNOSTIC DU SYSTÈME") print("=" * 60) for nom, valeur in informations.items(): print(f"{nom:22} : {valeur}") print("=" * 60) if __name__ == "__main__": informations = obtenir_informations() afficher_informations(informations) |
Sortie possible :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | ============================================================ DIAGNOSTIC DU SYSTÈME ============================================================ Système : Windows Release : 10 Version système : 10.0.19045 Machine : AMD64 Architecture : 64bit Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel Plateforme Python : win32 Version Python : 3.13.7 Implémentation : CPython Interpréteur : C:\Python313\python.exe Famille OS : nt Répertoire courant : C:\Users\Utilisateur\Documents PID : 8240 ============================================================ |
Nous pouvons compléter ce programme avec une fonction qui explique automatiquement la relation entre platform.system(), sys.platform et os.name.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | import platform import sys import os def comparer_plateformes(): print("platform.system() =", platform.system()) print("sys.platform =", sys.platform) print("os.name =", os.name) if platform.system() == "Windows": print("Windows a été détecté.") elif platform.system() == "Linux": print("Linux a été détecté.") elif platform.system() == "Darwin": print("macOS a été détecté.") else: print("Un autre système a été détecté.") comparer_plateformes() |
Sortie possible sous Linux :
1 2 3 4 | platform.system() = Linux sys.platform = linux os.name = posix Linux a été détecté. |
Cette organisation permet de créer un outil simple mais complet pour examiner à la fois le système d'exploitation, la plateforme Python et certains éléments de l'environnement du processus.
10. À retenir !
Les modules platform, sys et os fournissent tous des informations liées à l'environnement d'exécution, mais leurs objectifs sont différents et complémentaires.
- platform.system() retourne un nom lisible du système, comme "Windows", "Linux" ou "Darwin".
- sys.platform fournit un identifiant de plateforme utilisé par Python, comme "win32", "linux" ou "darwin".
- os.name identifie une famille de systèmes, par exemple "nt" ou "posix".
- Sous macOS, platform.system() retourne généralement "Darwin".
- Sous Windows, sys.platform retourne couramment "win32", même avec un Python 64 bits.
- os.name ne permet généralement pas de distinguer Linux de macOS, car les deux retournent "posix".
- Le module platform est particulièrement adapté à la collecte d'informations descriptives sur le système, la machine et Python.
- Le module sys est particulièrement adapté aux informations concernant l'interpréteur et l'environnement d'exécution Python.
- Le module os sert principalement d'interface avec les services du système d'exploitation.
- platform.machine() renseigne sur le type de machine rapporté par le système.
- sys.version_info permet d'examiner proprement les composantes de la version de Python.
- sys.executable fournit le chemin de l'interpréteur Python utilisé.
- os.getcwd() retourne le répertoire de travail courant.
- os.environ permet d'accéder aux variables d'environnement.
- Pour un diagnostic complet, les trois modules peuvent être utilisés ensemble.
Le programme suivant résume les principales différences entre les trois modules.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import platform import sys import os print("=== PLATFORM ===") print("Système :", platform.system()) print("Machine :", platform.machine()) print("Processeur :", platform.processor()) print("\n=== SYS ===") print("Plateforme :", sys.platform) print("Version Python :", sys.version_info[:3]) print("Interpréteur :", sys.executable) print("\n=== OS ===") print("Famille :", os.name) print("Répertoire courant :", os.getcwd()) print("PID :", os.getpid()) |
Sortie possible sous Windows :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | === PLATFORM === Système : Windows Machine : AMD64 Processeur : Intel64 Family 6 Model 142 Stepping 10, GenuineIntel === SYS === Plateforme : win32 Version Python : (3, 13, 7) Interpréteur : C:\Python313\python.exe === OS === Famille : nt Répertoire courant : C:\Users\Utilisateur\Documents PID : 8240 |
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/
