- À propos de platform.python_implementation() en Python
- Identifier l'implémentation Python utilisée
- Comprendre la valeur retournée par python_implementation()
- Découvrir les principales implémentations de Python
- Associer l'implémentation à la version de Python
- Tester l'implémentation Python dans un programme
- Associer l'implémentation à l'architecture Python
- Créer une fonction d'information sur l'environnement Python
- Utiliser python_implementation() dans un programme multiplateforme
- À retenir !
1. À propos de platform.python_implementation() en Python
Le langage Python peut être exécuté par différentes implémentations. La plus connue et la plus largement utilisée est CPython, mais il existe également d'autres implémentations telles que PyPy, Jython ou IronPython. Le module platform de la bibliothèque standard permet de déterminer facilement l'implémentation utilisée par le programme grâce à la fonction platform.python_implementation().
Cette information peut être utile pour réaliser un diagnostic de l'environnement Python, vérifier la compatibilité d'une bibliothèque ou adapter certaines parties d'un programme lorsque son comportement dépend de l'implémentation utilisée.
Le programme suivant importe le module platform puis affiche directement l'implémentation Python courante.
1 2 3 | import platform print(platform.python_implementation()) |
Sortie possible :
1 | CPython |
Sur une installation classique de Python provenant notamment de python.org, le résultat est généralement CPython.
2. Identifier l'implémentation Python utilisée
La fonction platform.python_implementation() ne nécessite aucun argument. Elle retourne le nom de l'implémentation Python utilisée pour exécuter le programme.
Nous pouvons stocker le résultat dans une variable afin de le réutiliser dans la suite du programme.
1 2 3 4 | import platform implementation = platform.python_implementation() print("Implémentation Python :", implementation) |
Sortie possible :
1 | Implémentation Python : CPython |
Il est également possible d'importer directement la fonction python_implementation() depuis le module platform.
1 2 3 | from platform import python_implementation print(python_implementation()) |
Sortie possible :
1 | CPython |
Les deux méthodes fournissent le même résultat. L'écriture platform.python_implementation() présente cependant l'avantage d'indiquer clairement que la fonction appartient au module platform.
3. Comprendre la valeur retournée par python_implementation()
La fonction platform.python_implementation() retourne le nom de l'implémentation sous forme d'une chaîne de caractères. Nous pouvons vérifier son type avec la fonction intégrée type().
Le programme suivant affiche à la fois l'implémentation et le type de la valeur retournée.
1 2 3 4 5 6 | import platform implementation = platform.python_implementation() print("Implémentation :", implementation) print("Type :", type(implementation)) |
Sortie possible :
1 2 | Implémentation : CPython Type : <class 'str'> |
Puisqu'il s'agit d'une chaîne, nous pouvons appliquer les méthodes classiques du type str. Nous pouvons par exemple convertir le nom en minuscules avec lower().
1 2 3 4 | import platform implementation = platform.python_implementation() print(implementation.lower()) |
Sortie possible :
1 | cpython |
Cette transformation peut être pratique lorsqu'un programme doit effectuer des comparaisons sans tenir compte des majuscules et des minuscules.
4. Découvrir les principales implémentations de Python
Python désigne avant tout un langage de programmation défini par ses spécifications. Plusieurs logiciels peuvent implémenter ce langage. La fonction platform.python_implementation() permet de savoir laquelle de ces implémentations exécute le programme.
CPython
CPython est l'implémentation de référence de Python et la plus couramment utilisée. Elle est principalement écrite en langage C. Sur une installation CPython, le programme suivant retourne CPython.
1 2 3 | import platform print(platform.python_implementation()) |
Sortie possible avec CPython :
1 | CPython |
PyPy
PyPy est une autre implémentation de Python, notamment connue pour l'utilisation d'un compilateur JIT dans son environnement d'exécution. Si le script est exécuté avec PyPy, python_implementation() permet de l'identifier.
1 2 3 | import platform print(platform.python_implementation()) |
Sortie possible avec PyPy :
1 | PyPy |
Jython et IronPython
D'autres implémentations existent, notamment Jython, associée à l'écosystème Java, et IronPython, conçue pour fonctionner avec l'environnement .NET. La valeur retournée dépend donc de l'interpréteur qui exécute réellement le programme.
1 2 3 4 | import platform implementation = platform.python_implementation() print("Python est exécuté avec :", implementation) |
Sortie possible :
1 | Python est exécuté avec : CPython |
Il est donc important de distinguer la version du langage Python de son implémentation.
5. Associer l'implémentation à la version de Python
Connaître uniquement l'implémentation n'indique pas la version de Python utilisée. Pour obtenir ces deux informations, nous pouvons associer platform.python_implementation() à platform.python_version().
Le programme suivant affiche l'implémentation puis la version de Python.
1 2 3 4 | import platform print("Implémentation :", platform.python_implementation()) print("Version :", platform.python_version()) |
Sortie possible :
1 2 | Implémentation : CPython Version : 3.14.1 |
Nous pouvons également utiliser platform.python_version_tuple() pour récupérer séparément les composantes majeure, mineure et micro de la version.
1 2 3 4 5 6 7 8 | import platform majeure, mineure, micro = platform.python_version_tuple() print("Implémentation :", platform.python_implementation()) print("Version majeure :", majeure) print("Version mineure :", mineure) print("Version micro :", micro) |
Sortie possible :
1 2 3 4 | Implémentation : CPython Version majeure : 3 Version mineure : 14 Version micro : 1 |
Ces informations permettent de décrire plus précisément l'environnement Python dans lequel l'application fonctionne.
6. Tester l'implémentation Python dans un programme
Comme platform.python_implementation() retourne une chaîne de caractères, nous pouvons utiliser son résultat dans une structure conditionnelle afin d'exécuter un traitement différent selon l'implémentation Python détectée.
Le programme suivant distingue quelques implémentations courantes.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import platform implementation = platform.python_implementation() if implementation == "CPython": print("L'interpréteur CPython est utilisé.") elif implementation == "PyPy": print("L'interpréteur PyPy est utilisé.") elif implementation == "Jython": print("L'interpréteur Jython est utilisé.") elif implementation == "IronPython": print("L'interpréteur IronPython est utilisé.") else: print("Autre implémentation :", implementation) |
Sortie possible :
1 | L'interpréteur CPython est utilisé. |
Nous pouvons également convertir le résultat en minuscules avant d'effectuer la comparaison.
1 2 3 4 5 6 7 8 | import platform implementation = platform.python_implementation().lower() if implementation == "cpython": print("CPython détecté.") else: print("Implémentation détectée :", implementation) |
Sortie possible :
1 | CPython détecté. |
Un tel test peut être utile lorsqu'une partie d'un programme dépend réellement de caractéristiques propres à une implémentation. Il est cependant préférable d'éviter les tests inutiles lorsque le même code peut fonctionner indépendamment de l'interpréteur.
7. Associer l'implémentation à l'architecture Python
Pour obtenir une description plus complète de l'environnement d'exécution, nous pouvons associer platform.python_implementation() à platform.architecture(). Cette dernière fournit notamment une indication telle que 32bit ou 64bit concernant l'exécutable examiné.
Le programme suivant affiche simultanément l'implémentation, la version et l'architecture de Python.
1 2 3 4 5 | import platform print("Implémentation :", platform.python_implementation()) print("Version :", platform.python_version()) print("Architecture :", platform.architecture()[0]) |
Sortie possible :
1 2 3 | Implémentation : CPython Version : 3.14.1 Architecture : 64bit |
Nous pouvons ajouter platform.machine() pour connaître également le type de machine rapporté par le système.
1 2 3 4 5 6 | import platform print("Implémentation :", platform.python_implementation()) print("Version Python :", platform.python_version()) print("Architecture Python :", platform.architecture()[0]) print("Machine :", platform.machine()) |
Sortie possible :
1 2 3 4 | Implémentation : CPython Version Python : 3.14.1 Architecture Python : 64bit Machine : AMD64 |
Il faut distinguer ces informations : python_implementation() identifie l'implémentation, python_version() donne la version Python, architecture() renseigne notamment sur le nombre de bits de l'exécutable et machine() décrit le type de machine rapporté par la plateforme.
8. Créer une fonction d'information sur l'environnement Python
Lorsque plusieurs informations concernant Python doivent être utilisées à différents endroits d'une application, nous pouvons créer une fonction qui rassemble les appels aux fonctions du module platform.
La fonction suivante retourne l'implémentation et la version de Python sous forme de dictionnaire.
1 2 3 4 5 6 7 8 9 10 | import platform def informations_python(): return { "implementation": platform.python_implementation(), "version": platform.python_version() } infos = informations_python() print(infos) |
Sortie possible :
1 | {'implementation': 'CPython', 'version': '3.14.1'} |
Nous pouvons enrichir cette fonction avec l'architecture Python, la machine et le système d'exploitation afin de créer une véritable fiche de diagnostic.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | import platform def environnement_python(): return { "implementation": platform.python_implementation(), "version": platform.python_version(), "architecture": platform.architecture()[0], "machine": platform.machine(), "systeme": platform.system() } infos = environnement_python() for cle, valeur in infos.items(): print(f"{cle} : {valeur}") |
Sortie possible :
1 2 3 4 5 | implementation : CPython version : 3.14.1 architecture : 64bit machine : AMD64 systeme : Windows |
Cette organisation est particulièrement pratique pour un outil de diagnostic, un script d'installation ou un programme devant transmettre des informations techniques sur son environnement d'exécution.
9. Utiliser python_implementation() dans un programme multiplateforme
La fonction platform.python_implementation() peut contribuer à rendre un programme plus robuste lorsqu'il doit fonctionner avec plusieurs implémentations de Python. Il faut cependant l'utiliser uniquement lorsque le comportement recherché dépend véritablement de l'implémentation.
Le programme suivant construit un message de diagnostic différent selon l'implémentation détectée.
1 2 3 4 5 6 7 8 9 10 11 12 13 | import platform implementation = platform.python_implementation() version = platform.python_version() if implementation == "CPython": message = f"CPython {version} est utilisé." elif implementation == "PyPy": message = f"PyPy compatible avec Python {version} est utilisé." else: message = f"{implementation} - version Python {version}" print(message) |
Sortie possible :
1 | CPython 3.14.1 est utilisé. |
Pour obtenir une vue plus générale de l'environnement, nous pouvons associer les informations concernant Python à celles du système d'exploitation.
1 2 3 4 5 6 | import platform print("Système :", platform.system()) print("Release :", platform.release()) print("Implémentation Python :", platform.python_implementation()) print("Version Python :", platform.python_version()) |
Sortie possible :
1 2 3 4 | Système : Windows Release : 11 Implémentation Python : CPython Version Python : 3.14.1 |
Cette combinaison permet d'identifier à la fois le système d'exploitation et l'environnement Python qui exécute le programme.
10. À retenir !
La fonction platform.python_implementation() permet d'identifier facilement l'implémentation Python qui exécute un programme. Elle appartient au module platform de la bibliothèque standard et ne nécessite donc l'installation d'aucun package supplémentaire.
- platform.python_implementation() ne nécessite aucun argument.
- La fonction retourne le nom de l'implémentation sous forme de chaîne de caractères.
- CPython est l'implémentation de référence et la plus couramment utilisée.
- PyPy est une autre implémentation de Python notamment connue pour son compilateur JIT.
- Jython est associé à l'écosystème Java.
- IronPython est conçu pour l'environnement .NET.
- platform.python_version() permet d'obtenir la version Python utilisée.
- platform.python_version_tuple() permet d'accéder séparément aux composantes de la version.
- platform.architecture() fournit des informations complémentaires concernant l'architecture de l'exécutable.
- Il faut distinguer l'implémentation Python, la version de Python, l'architecture de l'exécutable et l'architecture de la machine.
Le programme suivant rassemble les principales informations étudiées afin d'obtenir une fiche synthétique de l'environnement Python et du système.
1 2 3 4 5 6 7 8 9 | import platform print("Implémentation Python :", platform.python_implementation()) print("Version Python :", platform.python_version()) print("Architecture Python :", platform.architecture()[0]) print("Système :", platform.system()) print("Release :", platform.release()) print("Machine :", platform.machine()) print("Processeur :", platform.processor() or "Non disponible") |
Sortie possible :
1 2 3 4 5 6 7 | Implémentation Python : CPython Version Python : 3.14.1 Architecture Python : 64bit Système : Windows Release : 11 Machine : AMD64 Processeur : Intel64 Family 6 Model 154 Stepping 3, GenuineIntel |
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/
