- À propos de platform.machine() en Python
- Obtenir l'architecture de la machine
- Comprendre les valeurs retournées par platform.machine()
- Distinguer les architectures x86, AMD64 et ARM
- Associer l'architecture au système d'exploitation
- Tester l'architecture dans un programme Python
- Comparer platform.machine() et platform.architecture()
- Créer une fonction pour obtenir les informations matérielles
- Utiliser platform.machine() dans un programme multiplateforme
- À retenir !
1. À propos de platform.machine() en Python
Le module platform de Python fournit plusieurs fonctions permettant d'obtenir des informations sur le système et la machine sur lesquels un programme est exécuté. La fonction platform.machine() retourne une chaîne indiquant le type de machine ou l'architecture matérielle rapportée par le système.
Selon l'ordinateur et le système d'exploitation utilisés, cette fonction peut retourner des valeurs telles que AMD64, x86_64, i386, i686, arm64 ou aarch64. Le résultat dépend de la plateforme sur laquelle Python est exécuté.
Le programme suivant constitue l'utilisation la plus simple de platform.machine().
1 2 3 | import platform print(platform.machine()) |
Sortie possible :
1 | AMD64 |
Sur de nombreux ordinateurs Windows 64 bits équipés d'un processeur compatible x86-64, la valeur retournée peut être AMD64. Cette appellation désigne l'architecture et ne signifie pas nécessairement que le processeur physique est fabriqué par AMD.
2. Obtenir l'architecture de la machine
La fonction platform.machine() ne nécessite aucun argument. Après l'importation du module platform, nous pouvons appeler directement cette fonction et stocker son résultat dans une variable.
Le programme suivant enregistre l'information dans la variable architecture puis l'affiche avec un message explicatif.
1 2 3 4 | import platform architecture = platform.machine() print("Architecture de la machine :", architecture) |
Sortie possible :
1 | Architecture de la machine : AMD64 |
Il est également possible d'importer directement la fonction machine() depuis le module platform.
1 2 3 4 | from platform import machine architecture = machine() print(architecture) |
Sortie possible :
1 | x86_64 |
Les deux méthodes permettent d'obtenir le même type d'information. L'écriture platform.machine() présente toutefois l'avantage d'indiquer clairement que la fonction appartient au module platform.
3. Comprendre les valeurs retournées par platform.machine()
Le résultat de platform.machine() est une chaîne de caractères. Son contenu dépend du système d'exploitation, de la plateforme et des informations fournies à Python par l'environnement d'exécution.
Le programme suivant affiche la valeur retournée ainsi que son type Python.
1 2 3 4 5 6 | import platform architecture = platform.machine() print("Valeur :", architecture) print("Type :", type(architecture)) |
Sortie possible :
1 2 | Valeur : AMD64 Type : <class 'str'> |
Comme le résultat est de type str, nous pouvons utiliser les méthodes classiques des chaînes de caractères. Il est par exemple possible de convertir la valeur en minuscules pour faciliter certaines comparaisons.
1 2 3 4 | import platform architecture = platform.machine().lower() print(architecture) |
Sortie possible :
1 | amd64 |
Cette normalisation est utile lorsque nous voulons comparer plusieurs appellations possibles d'une architecture sans dépendre des majuscules et des minuscules.
4. Distinguer les architectures x86, AMD64 et ARM
Les valeurs retournées par platform.machine() peuvent varier selon les plateformes. Les architectures de la famille x86-64 peuvent notamment apparaître sous des appellations telles que AMD64 ou x86_64, tandis que les plateformes ARM 64 bits peuvent utiliser des valeurs telles que ARM64 ou aarch64.
Le programme suivant affiche simplement l'architecture détectée afin que nous puissions examiner la valeur réellement retournée par notre machine.
1 2 3 4 | import platform architecture = platform.machine() print("Architecture détectée :", architecture) |
Sortie possible sur Windows :
1 | Architecture détectée : AMD64 |
Sur une machine Linux x86-64, une autre appellation peut être retournée.
1 2 3 | import platform print(platform.machine()) |
Sortie possible sous Linux :
1 | x86_64 |
Sur une plateforme ARM 64 bits, le résultat peut encore être différent.
1 2 3 | import platform print(platform.machine()) |
Sortie possible sur une plateforme ARM :
1 | aarch64 |
Il est donc préférable de prévoir plusieurs appellations lorsque le programme doit reconnaître une famille d'architectures sur différents systèmes.
5. Associer l'architecture au système d'exploitation
La valeur retournée par platform.machine() devient plus informative lorsqu'elle est associée au système d'exploitation. Pour cela, nous pouvons utiliser simultanément platform.system() et platform.machine().
Le programme suivant affiche le système et l'architecture de la machine.
1 2 3 4 | import platform print("Système :", platform.system()) print("Architecture :", platform.machine()) |
Sortie possible :
1 2 | Système : Windows Architecture : AMD64 |
Nous pouvons compléter ces informations avec platform.release() afin d'obtenir également la release du système.
1 2 3 4 5 | import platform print("Système :", platform.system()) print("Release :", platform.release()) print("Architecture :", platform.machine()) |
Sortie possible :
1 2 3 | Système : Windows Release : 11 Architecture : AMD64 |
Cette combinaison est particulièrement utile pour construire une petite fiche de diagnostic système ou identifier l'environnement dans lequel une application Python est exécutée.
6. Tester l'architecture dans un programme Python
Comme platform.machine() retourne une chaîne, nous pouvons utiliser son résultat dans une structure conditionnelle. Il est cependant préférable de prévoir plusieurs appellations pour une même famille d'architectures.
Le programme suivant distingue simplement une architecture x86-64 d'une architecture ARM 64 bits.
1 2 3 4 5 6 7 8 9 10 | import platform architecture = platform.machine().lower() if architecture in ("amd64", "x86_64"): print("Architecture x86-64 détectée.") elif architecture in ("arm64", "aarch64"): print("Architecture ARM 64 bits détectée.") else: print("Autre architecture :", architecture) |
Sortie possible :
1 | Architecture x86-64 détectée. |
Nous pouvons également prévoir quelques appellations correspondant aux architectures x86 32 bits.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import platform architecture = platform.machine().lower() if architecture in ("amd64", "x86_64"): famille = "x86 64 bits" elif architecture in ("i386", "i686", "x86"): famille = "x86 32 bits" elif architecture in ("arm64", "aarch64"): famille = "ARM 64 bits" else: famille = "Architecture non classée" print(famille) |
Sortie possible :
1 | x86 64 bits |
Cette classification reste volontairement simple : de nombreuses architectures et variantes peuvent exister. Il convient donc d'adapter les tests aux plateformes réellement prises en charge par l'application.
7. Comparer platform.machine() et platform.architecture()
Le module platform fournit également la fonction platform.architecture(). Malgré son nom, elle ne fournit pas exactement la même information que platform.machine(). La première renvoie généralement un tuple contenant notamment une indication telle que 64bit ou 32bit, tandis que la seconde fournit le type de machine rapporté par le système.
Le programme suivant compare les résultats des deux fonctions.
1 2 3 4 | import platform print("Machine :", platform.machine()) print("Architecture :", platform.architecture()) |
Sortie possible :
1 2 | Machine : AMD64 Architecture : ('64bit', 'WindowsPE') |
Nous pouvons récupérer séparément les deux éléments retournés par platform.architecture().
1 2 3 4 5 6 | import platform bits, format_executable = platform.architecture() print("Taille :", bits) print("Format :", format_executable) |
Sortie possible sous Windows :
1 2 | Taille : 64bit Format : WindowsPE |
platform.machine() et platform.architecture() sont donc complémentaires, mais leurs résultats ne doivent pas être confondus. La première décrit le type de machine rapporté par la plateforme, tandis que la seconde fournit des informations relatives à l'architecture de l'exécutable Python utilisé.
8. Créer une fonction pour obtenir les informations matérielles
Lorsque plusieurs informations doivent être utilisées dans une application, nous pouvons créer une fonction Python qui regroupe les différents appels au module platform.
La fonction suivante retourne simplement la valeur obtenue avec platform.machine().
1 2 3 4 5 6 | import platform def obtenir_architecture(): return platform.machine() print(obtenir_architecture()) |
Sortie possible :
1 | AMD64 |
Nous pouvons ensuite créer une fonction plus complète qui retourne plusieurs informations sous forme de dictionnaire.
1 2 3 4 5 6 7 8 9 10 11 12 13 | import platform def informations_machine(): return { "nom": platform.node(), "systeme": platform.system(), "release": platform.release(), "machine": platform.machine(), "architecture": platform.architecture()[0] } infos = informations_machine() print(infos) |
Sortie possible :
1 | {'nom': 'PC-YOUNES', 'systeme': 'Windows', 'release': '11', 'machine': 'AMD64', 'architecture': '64bit'} |
Le dictionnaire facilite ensuite l'utilisation séparée des différentes informations. Par exemple, la valeur associée à la clé "machine" correspond au résultat de platform.machine().
9. Utiliser platform.machine() dans un programme multiplateforme
La fonction platform.machine() peut être utile lorsqu'un programme doit sélectionner une ressource ou un traitement selon l'architecture. C'est notamment le cas lorsqu'une application utilise des fichiers binaires différents pour les plateformes x86-64 et ARM64.
Le programme suivant choisit une configuration selon la famille d'architecture détectée.
1 2 3 4 5 6 7 8 9 10 11 12 | import platform architecture = platform.machine().lower() if architecture in ("amd64", "x86_64"): configuration = "Configuration pour x86-64" elif architecture in ("arm64", "aarch64"): configuration = "Configuration pour ARM64" else: configuration = "Configuration générique" print(configuration) |
Sortie possible :
1 | Configuration pour x86-64 |
Il faut cependant garder à l'esprit que platform.machine() décrit l'information rapportée par l'environnement d'exécution. Dans des contextes particuliers tels que la virtualisation, l'émulation ou certaines couches de compatibilité, cette valeur doit être interprétée avec prudence.
Le programme suivant affiche plusieurs informations simultanément afin de mieux replacer l'architecture dans son contexte.
1 2 3 4 5 6 7 | import platform print("Nom :", platform.node()) print("Système :", platform.system()) print("Release :", platform.release()) print("Machine :", platform.machine()) print("Architecture Python :", platform.architecture()[0]) |
Sortie possible :
1 2 3 4 5 | Nom : PC-YOUNES Système : Windows Release : 11 Machine : AMD64 Architecture Python : 64bit |
Cette approche est préférable lorsqu'un programme a besoin d'établir un diagnostic plus précis de son environnement d'exécution.
10. À retenir !
La fonction platform.machine() permet d'obtenir le type de machine ou l'architecture matérielle rapportée par le système. Elle appartient au module platform de la bibliothèque standard de Python et peut donc être utilisée sans installer de package supplémentaire.
- platform.machine() ne nécessite aucun argument.
- La fonction retourne une chaîne de caractères str.
- Des valeurs telles que AMD64, x86_64, arm64 ou aarch64 peuvent être retournées selon la plateforme.
- AMD64 désigne une architecture x86-64 et n'implique pas que le processeur soit obligatoirement fabriqué par AMD.
- Les appellations peuvent varier selon le système d'exploitation.
- platform.system() permet d'associer l'architecture au système d'exploitation.
- platform.node() permet d'ajouter le nom de la machine aux informations recueillies.
- platform.architecture() fournit des informations différentes et complémentaires concernant notamment l'exécutable Python.
- Il est conseillé de prévoir plusieurs appellations lorsqu'un programme doit reconnaître une famille d'architectures.
- Dans certains environnements virtualisés ou émulés, le résultat doit être interprété en tenant compte de l'environnement d'exécution.
Le programme suivant rassemble les principales informations étudiées et permet d'obtenir rapidement une fiche concernant le système et l'architecture de l'ordinateur.
1 2 3 4 5 6 7 8 | import platform print("Nom de la machine :", platform.node()) print("Système :", platform.system()) print("Release :", platform.release()) print("Machine :", platform.machine()) print("Architecture :", platform.architecture()[0]) print("Plateforme :", platform.platform()) |
Sortie possible :
1 2 3 4 5 6 | Nom de la machine : PC-YOUNES Système : Windows Release : 11 Machine : AMD64 Architecture : 64bit Plateforme : Windows-11-10.0.26100-SP0 |
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/
