- À propos de platform.node() en Python
- Obtenir simplement le nom de la machine
- Stocker le nom de la machine dans une variable
- Comprendre la valeur retournée par platform.node()
- Associer le nom de la machine au système d'exploitation
- Comparer le nom de la machine dans un programme
- Créer une fonction pour obtenir les informations de la machine
- Utiliser platform.node() pour identifier une machine
- Connaître les limites de platform.node()
- À retenir !
1. À propos de platform.node() en Python
Le module platform de Python fournit plusieurs fonctions permettant d'obtenir des informations sur l'environnement dans lequel un programme est exécuté. La fonction platform.node() permet notamment de récupérer le nom de la machine, généralement appelé nom d'hôte ou hostname.
Cette information peut être utile dans les programmes exécutés sur plusieurs ordinateurs, les scripts d'administration, les outils de diagnostic ou les applications qui doivent connaître la machine sur laquelle elles fonctionnent.
Le programme suivant importe le module platform puis utilise platform.node() pour afficher le nom de l'ordinateur.
1 2 3 | import platform print(platform.node()) |
Sortie possible :
1 | DESKTOP-7A2B3C |
La valeur affichée dépend naturellement du nom attribué à l'ordinateur. Sur une autre machine, le résultat sera donc différent.
2. Obtenir simplement le nom de la machine
La manière la plus simple d'utiliser platform.node() consiste à appeler directement la fonction après avoir importé le module platform. Aucun argument n'est nécessaire.
Le programme suivant ajoute un message devant le nom retourné afin de rendre l'affichage plus explicite.
1 2 3 | import platform print("Nom de la machine :", platform.node()) |
Sortie possible :
1 | Nom de la machine : PC-YOUNES |
platform.node() interroge les informations fournies par le système afin de récupérer le nom de la machine. Le même programme peut être utilisé sous Windows, Linux ou macOS.
Il est également possible d'importer directement la fonction node() depuis le module platform.
1 2 3 | from platform import node print(node()) |
Sortie possible :
1 | PC-YOUNES |
Dans ce cas, nous pouvons appeler directement node() sans écrire le préfixe platform..
3. Stocker le nom de la machine dans une variable
Dans une application réelle, il est souvent préférable de stocker le résultat de platform.node() dans une variable afin de pouvoir le réutiliser plusieurs fois sans répéter l'appel de la fonction.
Le programme suivant enregistre le nom de la machine dans la variable nom_machine avant de l'afficher.
1 2 3 4 | import platform nom_machine = platform.node() print("Machine actuelle :", nom_machine) |
Sortie possible :
1 | Machine actuelle : PC-YOUNES |
La variable nom_machine peut ensuite être utilisée dans des messages, des conditions, des fichiers de journalisation ou d'autres traitements.
Nous pouvons par exemple construire un message à l'aide d'une f-string.
1 2 3 4 5 | import platform nom_machine = platform.node() message = f"Le programme fonctionne sur la machine {nom_machine}." print(message) |
Sortie possible :
1 | Le programme fonctionne sur la machine PC-YOUNES. |
Cette technique facilite l'intégration du nom de l'ordinateur dans les messages générés par un programme Python.
4. Comprendre la valeur retournée par platform.node()
La fonction platform.node() retourne le nom de la machine sous la forme d'une chaîne de caractères. Il est donc possible d'appliquer au résultat les opérations habituelles disponibles sur les objets de type str.
Le programme suivant affiche la valeur retournée ainsi que son type.
1 2 3 4 5 | import platform nom_machine = platform.node() print("Nom :", nom_machine) print("Type :", type(nom_machine)) |
Sortie possible :
1 2 | Nom : PC-YOUNES Type : <class 'str'> |
Comme il s'agit d'une chaîne, nous pouvons par exemple utiliser la méthode upper() pour convertir le nom en majuscules.
1 2 3 4 | import platform nom_machine = platform.node() print(nom_machine.upper()) |
Sortie possible :
1 | PC-YOUNES |
Nous pouvons également déterminer le nombre de caractères composant le nom de la machine avec la fonction len().
1 2 3 4 | import platform nom_machine = platform.node() print("Nombre de caractères :", len(nom_machine)) |
Sortie possible :
1 | Nombre de caractères : 9 |
Le résultat dépend évidemment du nom configuré sur la machine qui exécute le programme.
5. Associer le nom de la machine au système d'exploitation
La fonction platform.node() peut être associée à platform.system() afin d'obtenir simultanément le nom de la machine et son système d'exploitation.
Le programme suivant affiche ces deux informations.
1 2 3 4 | import platform print("Machine :", platform.node()) print("Système :", platform.system()) |
Sortie possible :
1 2 | Machine : PC-YOUNES Système : Windows |
Nous pouvons compléter ces informations avec platform.release(), qui fournit des informations sur la version ou la publication du système.
1 2 3 4 5 | import platform print("Machine :", platform.node()) print("Système :", platform.system()) print("Release :", platform.release()) |
Sortie possible :
1 2 3 | Machine : PC-YOUNES Système : Windows Release : 11 |
Ces fonctions permettent de construire rapidement une petite fiche d'identification de l'environnement sur lequel le programme Python fonctionne.
6. Comparer le nom de la machine dans un programme
Puisque platform.node() retourne une chaîne de caractères, nous pouvons utiliser son résultat dans une structure conditionnelle if. Cela permet par exemple d'exécuter un traitement particulier lorsqu'un programme fonctionne sur une machine déterminée.
Le programme suivant vérifie si le nom de la machine correspond à PC-YOUNES.
1 2 3 4 5 6 7 8 | import platform nom_machine = platform.node() if nom_machine == "PC-YOUNES": print("Machine principale détectée.") else: print("Autre machine détectée.") |
Sortie possible :
1 | Machine principale détectée. |
Cette technique peut être utilisée pour choisir une configuration spécifique, mais il est préférable de ne pas dépendre inutilement du nom d'un ordinateur lorsque le programme peut être conçu de manière multiplateforme et indépendante de la machine.
Pour éviter les différences liées aux majuscules et aux minuscules, nous pouvons normaliser la valeur avant de la comparer.
1 2 3 4 5 6 7 8 | import platform nom_machine = platform.node().lower() if nom_machine == "pc-younes": print("Machine reconnue.") else: print("Machine non reconnue.") |
Sortie possible :
1 | Machine reconnue. |
La méthode lower() convertit le nom en minuscules avant d'effectuer la comparaison.
7. Créer une fonction pour obtenir les informations de la machine
Lorsque les informations sur la machine sont nécessaires à plusieurs endroits du programme, nous pouvons créer une fonction qui rassemble les différents appels au module platform.
La fonction suivante retourne le nom de la machine obtenu avec platform.node().
1 2 3 4 5 6 | import platform def obtenir_nom_machine(): return platform.node() print(obtenir_nom_machine()) |
Sortie possible :
1 | PC-YOUNES |
Nous pouvons développer cette fonction afin qu'elle retourne plusieurs informations dans un dictionnaire Python.
1 2 3 4 5 6 7 8 9 10 11 12 | import platform def informations_machine(): return { "nom": platform.node(), "systeme": platform.system(), "release": platform.release(), "machine": platform.machine() } infos = informations_machine() print(infos) |
Sortie possible :
1 | {'nom': 'PC-YOUNES', 'systeme': 'Windows', 'release': '11', 'machine': 'AMD64'} |
Cette structure facilite l'accès aux différentes informations. Nous pouvons par exemple récupérer uniquement le nom avec infos["nom"].
8. Utiliser platform.node() pour identifier une machine
La fonction platform.node() peut être utile dans un outil de diagnostic, un programme d'administration ou un système de journalisation. Elle permet d'ajouter le nom de la machine aux informations produites par le programme.
Le programme suivant génère une petite fiche contenant le nom de l'ordinateur, le système et l'architecture rapportée par Python.
1 2 3 4 5 6 7 8 | import platform print("Informations sur la machine") print("---------------------------") print("Nom :", platform.node()) print("Système :", platform.system()) print("Version :", platform.release()) print("Architecture :", platform.machine()) |
Sortie possible :
1 2 3 4 5 6 | Informations sur la machine --------------------------- Nom : PC-YOUNES Système : Windows Version : 11 Architecture : AMD64 |
Dans un programme exécuté sur plusieurs ordinateurs, cette fiche peut aider à savoir sur quelle machine un résultat, une erreur ou une opération a été produit.
Nous pouvons également générer une chaîne synthétique réunissant plusieurs informations.
1 2 3 4 | import platform identite = f"{platform.node()} - {platform.system()} - {platform.machine()}" print(identite) |
Sortie possible :
1 | PC-YOUNES - Windows - AMD64 |
Cette représentation compacte peut notamment être intégrée à des messages de diagnostic ou à des journaux techniques.
9. Connaître les limites de platform.node()
La fonction platform.node() est pratique, mais le nom retourné dépend de la configuration du système et de l'environnement dans lequel Python fonctionne. Il ne faut donc pas considérer cette valeur comme un identifiant unique et permanent de l'ordinateur.
Un administrateur ou un utilisateur peut notamment modifier le nom d'une machine. Dans certains environnements particuliers, la fonction peut également retourner une chaîne vide lorsqu'il est impossible de déterminer le nom.
Le programme suivant prévoit ce cas en testant le résultat avant de l'utiliser.
1 2 3 4 5 6 7 8 | import platform nom_machine = platform.node() if nom_machine: print("Nom de la machine :", nom_machine) else: print("Nom de la machine indisponible.") |
Sortie possible :
1 | Nom de la machine : PC-YOUNES |
Ce test rend le programme plus robuste lorsqu'il est exécuté dans différents environnements.
Nous pouvons également fournir une valeur par défaut lorsque le nom n'est pas disponible.
1 2 3 4 | import platform nom_machine = platform.node() or "Machine inconnue" print(nom_machine) |
Sortie possible :
1 | PC-YOUNES |
Si platform.node() retourne une chaîne vide, l'expression utilise alors automatiquement la valeur "Machine inconnue".
10. À retenir !
La fonction platform.node() du module platform permet d'obtenir facilement le nom de la machine sur laquelle un programme Python est exécuté. Elle est particulièrement utile pour les programmes de diagnostic, les scripts d'administration et les applications exécutées sur plusieurs ordinateurs.
- platform.node() retourne généralement le nom de la machine ou son nom d'hôte.
- Le module platform appartient à la bibliothèque standard de Python.
- Aucun argument n'est nécessaire pour appeler platform.node().
- Le résultat est retourné sous forme de chaîne de caractères str.
- La valeur peut être stockée dans une variable et réutilisée dans le programme.
- platform.system() peut compléter le nom de la machine avec le système d'exploitation.
- platform.release() permet d'obtenir une information complémentaire sur la version du système.
- platform.machine() fournit une information concernant le type de machine ou l'architecture rapportée par le système.
- Le nom retourné ne doit pas être considéré comme un identifiant unique et permanent de l'ordinateur.
- Il est conseillé de prévoir le cas où platform.node() ne parvient pas à fournir un nom.
Le programme suivant rassemble les principales notions étudiées et affiche une fiche simple décrivant la machine sur laquelle Python est exécuté.
1 2 3 4 5 6 7 8 | import platform nom = platform.node() or "Machine inconnue" print("Nom de la machine :", nom) print("Système :", platform.system()) print("Release :", platform.release()) print("Machine :", platform.machine()) |
Sortie possible :
1 2 3 4 | Nom de la machine : PC-YOUNES Système : Windows Release : 11 Machine : AMD64 |
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/
