- À propos des versions de Python avec le module platform
- Obtenir la version de Python avec platform.python_version()
- Décomposer la version avec platform.python_version_tuple()
- Comprendre les numéros majeur, mineur et micro
- Comparer python_version() et python_version_tuple()
- Tester la version de Python dans un programme
- Vérifier une version minimale de Python
- Afficher la version avec l'implémentation de Python
- Créer une fonction d'information sur la version de Python
- À retenir !
1. À propos des versions de Python avec le module platform
Le module platform de la bibliothèque standard de Python fournit plusieurs fonctions permettant d'obtenir des informations sur le système d'exploitation, la machine et l'environnement Python. Parmi ces fonctions, platform.python_version() et platform.python_version_tuple() permettent de connaître précisément la version de Python utilisée pour exécuter un programme.
Une version de Python est généralement composée de trois parties : une version majeure, une version mineure et une version micro. Une version telle que Python 3.14.1 possède ainsi le numéro majeur 3, le numéro mineur 14 et le numéro micro 1.
Le programme suivant affiche les informations fournies par les deux fonctions afin d'observer immédiatement la différence entre leurs résultats.
1 2 3 4 | import platform print(platform.python_version()) print(platform.python_version_tuple()) |
Sortie possible :
1 2 | 3.14.1 ('3', '14', '1') |
python_version() retourne donc la version complète sous forme d'une chaîne, tandis que python_version_tuple() la décompose en plusieurs éléments regroupés dans un tuple.
2. Obtenir la version de Python avec platform.python_version()
La fonction platform.python_version() permet d'obtenir directement la version de Python actuellement utilisée. Elle ne nécessite aucun argument et retourne le numéro de version sous forme de chaîne de caractères.
Le programme suivant affiche simplement la version de Python utilisée pour exécuter le script.
1 2 3 | import platform print("Version de Python :", platform.python_version()) |
Sortie possible :
1 | Version de Python : 3.14.1 |
Nous pouvons également stocker cette information dans une variable afin de la réutiliser dans le programme.
1 2 3 4 5 6 | import platform version_python = platform.python_version() print("Python", version_python) print("Type :", type(version_python)) |
Sortie possible :
1 2 | Python 3.14.1 Type : <class 'str'> |
La valeur retournée étant de type str, elle peut facilement être insérée dans un message, enregistrée dans un fichier de diagnostic ou affichée dans l'interface d'une application.
3. Décomposer la version avec platform.python_version_tuple()
La fonction platform.python_version_tuple() fournit les différents composants de la version Python sous la forme d'un tuple. Cette représentation est particulièrement pratique lorsque nous souhaitons accéder séparément aux différentes parties du numéro de version.
Le programme suivant affiche directement le tuple retourné par la fonction ainsi que son type.
1 2 3 4 5 6 | import platform version = platform.python_version_tuple() print("Version :", version) print("Type :", type(version)) |
Sortie possible :
1 2 | Version : ('3', '14', '1') Type : <class 'tuple'> |
Nous pouvons accéder individuellement aux trois éléments avec les indices 0, 1 et 2.
1 2 3 4 5 6 7 | import platform version = platform.python_version_tuple() print("Version majeure :", version[0]) print("Version mineure :", version[1]) print("Version micro :", version[2]) |
Sortie possible :
1 2 3 | Version majeure : 3 Version mineure : 14 Version micro : 1 |
Les éléments du tuple sont eux-mêmes des chaînes de caractères. Lorsque nous souhaitons effectuer des comparaisons numériques, il peut donc être nécessaire de les convertir avec int().
4. Comprendre les numéros majeur, mineur et micro
Le numéro d'une version Python est généralement organisé selon trois composantes. La première correspond à la version majeure, la deuxième à la version mineure et la troisième à la version micro.
Version majeure
La version majeure représente une évolution importante du langage. Dans Python 3.14.1, le numéro majeur est 3.
Version mineure
La version mineure correspond à une évolution de la branche majeure apportant notamment de nouvelles fonctionnalités. Dans Python 3.14.1, le numéro mineur est 14.
Version micro
La version micro correspond aux versions de maintenance d'une branche donnée. Dans Python 3.14.1, le numéro micro est 1.
Le déballage du tuple permet de placer directement ces trois éléments dans trois variables distinctes.
1 2 3 4 5 6 7 | import platform majeure, mineure, micro = platform.python_version_tuple() print("Majeure :", majeure) print("Mineure :", mineure) print("Micro :", micro) |
Sortie possible :
1 2 3 | Majeure : 3 Mineure : 14 Micro : 1 |
Nous pouvons également reconstruire une phrase complète à partir des trois variables.
1 2 3 4 5 | import platform majeure, mineure, micro = platform.python_version_tuple() print(f"Python version {majeure}.{mineure}.{micro}") |
Sortie possible :
1 | Python version 3.14.1 |
Cette méthode est utile lorsque chaque composante de la version doit être utilisée séparément dans le programme.
5. Comparer python_version() et python_version_tuple()
Les fonctions platform.python_version() et platform.python_version_tuple() fournissent la même information générale, mais sous deux formes différentes. La première privilégie un affichage direct tandis que la seconde facilite l'accès aux différentes composantes de la version.
Le programme suivant compare les deux résultats.
1 2 3 4 5 6 7 | import platform version_complete = platform.python_version() version_detaillee = platform.python_version_tuple() print("Version complète :", version_complete) print("Version détaillée :", version_detaillee) |
Sortie possible :
1 2 | Version complète : 3.14.1 Version détaillée : ('3', '14', '1') |
Nous pouvons également afficher le type de chacune des valeurs retournées.
1 2 3 4 5 6 7 | import platform version_complete = platform.python_version() version_detaillee = platform.python_version_tuple() print(type(version_complete)) print(type(version_detaillee)) |
Sortie :
1 2 | <class 'str'> <class 'tuple'> |
python_version() convient donc particulièrement à l'affichage de la version complète, tandis que python_version_tuple() est pratique lorsque nous souhaitons manipuler séparément les différentes parties du numéro de version.
6. Tester la version de Python dans un programme
La fonction platform.python_version_tuple() peut être utilisée dans une structure conditionnelle afin d'adapter un programme à la version de Python installée. Les éléments retournés étant des chaînes, il est préférable de les convertir en nombres entiers pour effectuer des comparaisons numériques.
Le programme suivant récupère la version majeure puis vérifie si le programme fonctionne avec Python 3.
1 2 3 4 5 6 7 8 | import platform majeure = int(platform.python_version_tuple()[0]) if majeure == 3: print("Python 3 est utilisé.") else: print("Une autre version majeure de Python est utilisée.") |
Sortie possible :
1 | Python 3 est utilisé. |
Nous pouvons également examiner la version mineure afin d'effectuer un test plus précis.
1 2 3 4 5 6 7 8 9 10 11 | import platform majeure, mineure, micro = platform.python_version_tuple() majeure = int(majeure) mineure = int(mineure) if majeure == 3 and mineure >= 14: print("Python 3.14 ou une version ultérieure de Python 3 est utilisée.") else: print("Version antérieure à Python 3.14.") |
Sortie possible :
1 | Python 3.14 ou une version ultérieure de Python 3 est utilisée. |
La conversion avec int() évite les erreurs liées aux comparaisons lexicographiques de chaînes telles que "9" et "14".
7. Vérifier une version minimale de Python
Certains programmes nécessitent une version minimale de Python pour fonctionner correctement. Nous pouvons convertir les trois éléments retournés par platform.python_version_tuple() en entiers puis effectuer une comparaison de tuples numériques.
Le programme suivant vérifie si Python 3.10 ou une version plus récente est disponible.
1 2 3 4 5 6 7 8 9 | import platform majeure, mineure, micro = map(int, platform.python_version_tuple()) version_actuelle = (majeure, mineure, micro) if version_actuelle >= (3, 10, 0): print("Version de Python compatible.") else: print("Python 3.10 ou supérieur est nécessaire.") |
Sortie possible :
1 | Version de Python compatible. |
Python compare les tuples élément par élément. Cette technique permet donc de comparer correctement des versions telles que 3.9.0, 3.10.0, 3.13.2 ou 3.14.1.
Nous pouvons afficher la version actuelle lorsque la version minimale n'est pas satisfaite ou simplement pour informer l'utilisateur.
1 2 3 4 5 6 7 8 9 | import platform version = platform.python_version() majeure, mineure, micro = map(int, platform.python_version_tuple()) if (majeure, mineure, micro) >= (3, 12, 0): print(f"Python {version} : version compatible.") else: print(f"Python {version} : version trop ancienne.") |
Sortie possible :
1 | Python 3.14.1 : version compatible. |
Ce type de vérification est utile au démarrage d'une application qui dépend de fonctionnalités introduites dans une version précise de Python.
8. Afficher la version avec l'implémentation de Python
Le numéro de version ne constitue qu'une partie des informations concernant l'environnement Python. Le module platform fournit également platform.python_implementation(), qui permet de connaître l'implémentation Python utilisée, par exemple CPython, PyPy ou Jython selon l'environnement.
Le programme suivant associe le numéro de version à l'implémentation 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 ajouter l'architecture de l'exécutable afin d'obtenir une description plus complète de l'environnement 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 |
Cette combinaison est particulièrement intéressante dans un outil de diagnostic Python, car elle permet de connaître simultanément l'implémentation, la version et l'architecture de l'environnement d'exécution.
9. Créer une fonction d'information sur la version de Python
Lorsque les informations concernant Python doivent être utilisées à plusieurs endroits d'une application, nous pouvons créer une fonction qui regroupe les appels aux différentes fonctions du module platform.
La fonction suivante retourne la version complète ainsi que ses trois composantes dans un dictionnaire.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | import platform def informations_version_python(): majeure, mineure, micro = platform.python_version_tuple() return { "version": platform.python_version(), "majeure": majeure, "mineure": mineure, "micro": micro } infos = informations_version_python() print(infos) |
Sortie possible :
1 | {'version': '3.14.1', 'majeure': '3', 'mineure': '14', 'micro': '1'} |
Nous pouvons enrichir cette fonction avec l'implémentation et l'architecture de Python afin de construire une fiche plus complète.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | import platform def informations_python(): majeure, mineure, micro = platform.python_version_tuple() return { "implementation": platform.python_implementation(), "version": platform.python_version(), "majeure": majeure, "mineure": mineure, "micro": micro, "architecture": platform.architecture()[0] } infos = informations_python() for cle, valeur in infos.items(): print(f"{cle} : {valeur}") |
Sortie possible :
1 2 3 4 5 6 | implementation : CPython version : 3.14.1 majeure : 3 mineure : 14 micro : 1 architecture : 64bit |
Une telle fonction peut être intégrée à un programme de diagnostic, un installateur ou une application qui doit vérifier son environnement Python avant d'exécuter certaines fonctionnalités.
10. À retenir !
Les fonctions platform.python_version() et platform.python_version_tuple() permettent de connaître précisément la version de Python utilisée pour exécuter un programme. Elles appartiennent au module platform de la bibliothèque standard et ne nécessitent donc l'installation d'aucun package supplémentaire.
- platform.python_version() retourne la version complète de Python sous forme de chaîne de caractères.
- Une valeur telle que 3.14.1 représente les versions majeure, mineure et micro.
- platform.python_version_tuple() retourne les différentes composantes sous forme d'un tuple.
- Le tuple peut par exemple être ('3', '14', '1').
- Les éléments de python_version_tuple() sont des chaînes de caractères.
- La fonction int() permet de convertir une composante en entier pour effectuer une comparaison numérique.
- map(int, platform.python_version_tuple()) permet de convertir les trois composantes en nombres entiers.
- Une comparaison de tuples numériques peut servir à vérifier une version minimale de Python.
- platform.python_implementation() permet de connaître l'implémentation Python utilisée.
- Ces fonctions sont particulièrement utiles pour les diagnostics, les vérifications de compatibilité et les scripts d'installation.
Le programme suivant rassemble les principales informations étudiées dans ce tutoriel afin d'afficher une fiche synthétique de l'environnement Python.
1 2 3 4 5 6 7 8 9 10 | import platform majeure, mineure, micro = platform.python_version_tuple() print("Implémentation :", platform.python_implementation()) print("Version complète :", platform.python_version()) print("Version majeure :", majeure) print("Version mineure :", mineure) print("Version micro :", micro) print("Architecture :", platform.architecture()[0]) |
Sortie possible :
1 2 3 4 5 6 | Implémentation : CPython Version complète : 3.14.1 Version majeure : 3 Version mineure : 14 Version micro : 1 Architecture : 64bit |
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/
