- À propos de platform.architecture() en Python
- Obtenir l'architecture de Python avec platform.architecture()
- Comprendre le tuple retourné par platform.architecture()
- Distinguer Python 32 bits et Python 64 bits
- Récupérer séparément le nombre de bits et le format de l'exécutable
- Comparer platform.architecture() et platform.machine()
- Tester l'architecture Python dans un programme
- Obtenir l'architecture d'un exécutable avec executable
- Créer une fonction d'information sur l'architecture Python
- À retenir !
1. À propos de platform.architecture() en Python
Le module platform de Python fournit plusieurs fonctions permettant d'obtenir des informations sur le système, la machine et l'interpréteur Python. La fonction platform.architecture() permet notamment d'obtenir des informations sur l'architecture de l'exécutable utilisé, avec une indication telle que 32bit ou 64bit.
Cette fonction est utile lorsqu'un programme doit connaître l'architecture de l'interpréteur Python en cours d'utilisation, par exemple pour vérifier la compatibilité avec une bibliothèque native, sélectionner une ressource adaptée ou réaliser un diagnostic de l'environnement d'exécution.
Le programme suivant importe le module platform puis affiche directement le résultat retourné par platform.architecture().
1 2 3 | import platform print(platform.architecture()) |
Sortie possible sous Windows :
1 | ('64bit', 'WindowsPE') |
La fonction retourne ici un tuple contenant deux chaînes. La première indique une architecture 64 bits et la seconde fournit une information concernant le format de l'exécutable.
2. Obtenir l'architecture de Python avec platform.architecture()
L'utilisation de platform.architecture() est simple puisque la fonction peut être appelée sans argument pour obtenir des informations concernant l'exécutable Python courant.
Le programme suivant stocke le résultat dans une variable avant de l'afficher.
1 2 3 4 | import platform architecture = platform.architecture() print("Architecture Python :", architecture) |
Sortie possible :
1 | Architecture Python : ('64bit', 'WindowsPE') |
Il est également possible d'importer directement la fonction architecture() depuis le module platform.
1 2 3 | from platform import architecture print(architecture()) |
Sortie possible :
1 | ('64bit', 'WindowsPE') |
Les deux écritures permettent d'obtenir la même information. L'utilisation de platform.architecture() rend toutefois immédiatement visible l'appartenance de la fonction au module platform.
3. Comprendre le tuple retourné par platform.architecture()
Contrairement à platform.machine(), qui retourne une chaîne, platform.architecture() retourne un tuple de deux éléments. Le premier élément indique le nombre de bits et le second fournit le format de liaison ou de l'exécutable lorsqu'il peut être déterminé.
Le programme suivant affiche le résultat puis vérifie son type avec type().
1 2 3 4 5 6 | import platform architecture = platform.architecture() print("Résultat :", architecture) print("Type :", type(architecture)) |
Sortie possible :
1 2 | Résultat : ('64bit', 'WindowsPE') Type : <class 'tuple'> |
Nous pouvons accéder au premier élément du tuple avec l'indice 0 et au second avec l'indice 1.
1 2 3 4 5 6 | import platform architecture = platform.architecture() print("Bits :", architecture[0]) print("Format :", architecture[1]) |
Sortie possible :
1 2 | Bits : 64bit Format : WindowsPE |
Cette organisation permet d'utiliser séparément les deux informations dans la suite du programme.
4. Distinguer Python 32 bits et Python 64 bits
L'une des principales utilisations de platform.architecture() consiste à savoir si l'exécutable Python concerné est identifié comme 32 bits ou 64 bits. Cette distinction peut être importante pour certaines bibliothèques comportant du code compilé.
Le programme suivant affiche uniquement le premier élément retourné par platform.architecture().
1 2 3 4 | import platform bits = platform.architecture()[0] print("Architecture de Python :", bits) |
Sortie possible avec Python 64 bits :
1 | Architecture de Python : 64bit |
Avec un exécutable Python 32 bits, une sortie telle que la suivante peut être obtenue.
1 2 3 4 | import platform bits = platform.architecture()[0] print("Architecture de Python :", bits) |
Sortie possible avec Python 32 bits :
1 | Architecture de Python : 32bit |
Il est important de distinguer l'architecture de Python de l'architecture générale de l'ordinateur ou du système. Un système 64 bits peut, dans certains contextes, exécuter un interpréteur Python 32 bits.
5. Récupérer séparément le nombre de bits et le format de l'exécutable
Comme platform.architecture() retourne deux éléments, Python permet d'utiliser le déballage de tuple pour placer directement chaque valeur dans une variable distincte. Cette écriture est généralement plus lisible que l'utilisation des indices.
Le programme suivant place le premier élément dans bits et le second dans format_executable.
1 2 3 4 5 6 | import platform bits, format_executable = platform.architecture() print("Nombre de bits :", bits) print("Format :", format_executable) |
Sortie possible sous Windows :
1 2 | Nombre de bits : 64bit Format : WindowsPE |
Nous pouvons ensuite utiliser ces variables indépendamment dans le programme. L'exemple suivant construit une phrase à partir des deux informations.
1 2 3 4 5 | import platform bits, format_executable = platform.architecture() message = f"Python utilise une architecture {bits}, format {format_executable}." print(message) |
Sortie possible :
1 | Python utilise une architecture 64bit, format WindowsPE. |
Le contenu du second élément dépend de la plateforme et peut être différent de WindowsPE sur d'autres systèmes.
6. Comparer platform.architecture() et platform.machine()
Les fonctions platform.architecture() et platform.machine() concernent toutes les deux l'architecture, mais elles ne retournent pas la même information. platform.machine() indique le type de machine rapporté par le système, tandis que platform.architecture() fournit notamment une indication sur le nombre de bits de l'exécutable examiné.
Le programme suivant permet de comparer directement leurs résultats.
1 2 3 4 | import platform print("Machine :", platform.machine()) print("Architecture Python :", platform.architecture()) |
Sortie possible sous Windows :
1 2 | Machine : AMD64 Architecture Python : ('64bit', 'WindowsPE') |
Dans cet exemple, AMD64 décrit le type de machine rapporté par la plateforme, tandis que 64bit indique la largeur en bits déterminée pour l'exécutable.
Nous pouvons compléter la comparaison avec le système d'exploitation afin d'obtenir un résultat plus explicite.
1 2 3 4 5 | import platform print("Système :", platform.system()) print("Machine :", platform.machine()) print("Python :", platform.architecture()[0]) |
Sortie possible :
1 2 3 | Système : Windows Machine : AMD64 Python : 64bit |
Ces informations sont complémentaires et permettent de mieux décrire l'environnement d'exécution Python.
7. Tester l'architecture Python dans un programme
Le premier élément retourné par platform.architecture() étant une chaîne, nous pouvons l'utiliser dans une structure conditionnelle afin d'effectuer un traitement différent selon que Python est détecté en 32 bits ou en 64 bits.
Le programme suivant teste l'architecture et affiche un message adapté.
1 2 3 4 5 6 7 8 9 10 | import platform bits = platform.architecture()[0] if bits == "64bit": print("Python 64 bits détecté.") elif bits == "32bit": print("Python 32 bits détecté.") else: print("Architecture Python :", bits) |
Sortie possible :
1 | Python 64 bits détecté. |
Nous pouvons également utiliser cette information pour sélectionner une configuration particulière.
1 2 3 4 5 6 7 8 9 10 | import platform bits = platform.architecture()[0] if bits == "64bit": configuration = "Configuration pour Python 64 bits" else: configuration = "Configuration pour une autre architecture" print(configuration) |
Sortie possible :
1 | Configuration pour Python 64 bits |
Ce type de test peut être utile lorsqu'une ressource externe ou une bibliothèque native existe sous plusieurs variantes adaptées à différentes architectures.
8. Obtenir l'architecture d'un exécutable avec executable
La fonction platform.architecture() accepte également un paramètre executable. Par défaut, elle examine l'exécutable Python courant, mais il est possible de lui transmettre le chemin d'un autre fichier exécutable lorsque la plateforme permet d'en déterminer l'architecture.
Pour connaître le chemin de l'interpréteur Python actuellement utilisé, nous pouvons d'abord employer sys.executable.
1 2 3 | import sys print(sys.executable) |
Sortie possible sous Windows :
1 | C:\Python314\python.exe |
Nous pouvons ensuite transmettre explicitement ce chemin à platform.architecture(). Dans cet exemple, nous examinons donc le même interpréteur que celui qui exécute le programme.
1 2 3 4 5 | import platform import sys architecture = platform.architecture(sys.executable) print(architecture) |
Sortie possible :
1 | ('64bit', 'WindowsPE') |
La fonction possède également les paramètres bits et linkage, qui servent de valeurs par défaut lorsque les informations correspondantes ne peuvent pas être déterminées.
L'exemple suivant montre leur utilisation explicite avec l'exécutable Python courant.
1 2 3 4 5 6 7 8 9 10 | import platform import sys resultat = platform.architecture( executable=sys.executable, bits="inconnu", linkage="inconnu" ) print(resultat) |
Sortie possible :
1 | ('64bit', 'WindowsPE') |
Lorsque Python parvient à déterminer l'architecture et le format, les valeurs détectées remplacent les valeurs par défaut indiquées dans l'appel.
9. Créer une fonction d'information sur l'architecture Python
Lorsque les informations d'architecture sont utilisées à plusieurs endroits d'une application, il peut être pratique de créer une fonction qui rassemble les appels nécessaires au module platform.
La fonction suivante retourne les deux informations fournies par platform.architecture() dans un dictionnaire.
1 2 3 4 5 6 7 8 9 10 11 | import platform def architecture_python(): bits, format_executable = platform.architecture() return { "bits": bits, "format": format_executable } infos = architecture_python() print(infos) |
Sortie possible :
1 | {'bits': '64bit', 'format': 'WindowsPE'} |
Nous pouvons enrichir cette fonction avec d'autres informations fournies par le module platform afin de construire une fiche plus complète de l'environnement Python.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import platform def informations_architecture(): bits, format_executable = platform.architecture() return { "systeme": platform.system(), "machine": platform.machine(), "bits_python": bits, "format": format_executable } infos = informations_architecture() for cle, valeur in infos.items(): print(f"{cle} : {valeur}") |
Sortie possible :
1 2 3 4 | systeme : Windows machine : AMD64 bits_python : 64bit format : WindowsPE |
Cette organisation est particulièrement utile pour les programmes de diagnostic, les scripts d'installation ou les applications qui doivent vérifier certaines caractéristiques de leur environnement d'exécution.
10. À retenir !
La fonction platform.architecture() permet d'obtenir des informations sur l'architecture de l'exécutable Python ou d'un autre exécutable indiqué. Elle appartient au module platform de la bibliothèque standard et peut donc être utilisée sans installer de package supplémentaire.
- platform.architecture() retourne un tuple contenant deux chaînes de caractères.
- Le premier élément indique généralement une valeur telle que 32bit ou 64bit.
- Le second élément fournit une information concernant le format ou le linkage de l'exécutable.
- Sous Windows, une sortie courante est ('64bit', 'WindowsPE').
- Le déballage de tuple permet de récupérer directement les deux valeurs dans des variables.
- platform.architecture()[0] permet de récupérer uniquement l'indication 32 ou 64 bits.
- platform.machine() et platform.architecture() ne fournissent pas exactement la même information.
- platform.machine() peut retourner des valeurs telles que AMD64, x86_64 ou ARM64.
- Le paramètre executable permet de demander l'architecture d'un exécutable déterminé lorsque cette information peut être obtenue.
- Il est important de distinguer l'architecture de l'interpréteur Python de l'architecture générale de la machine.
Le programme suivant rassemble les principales informations étudiées dans ce tutoriel afin d'obtenir une fiche synthétique de l'architecture de l'environnement Python.
1 2 3 4 5 6 7 8 9 10 | import platform import sys bits, format_executable = platform.architecture() print("Exécutable Python :", sys.executable) print("Système :", platform.system()) print("Machine :", platform.machine()) print("Architecture Python :", bits) print("Format :", format_executable) |
Sortie possible :
1 2 3 4 5 | Exécutable Python : C:\Python314\python.exe Système : Windows Machine : AMD64 Architecture Python : 64bit Format : WindowsPE |
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/
