Comment puis-je vérifier la version Python dans un programme qui utilise de nouvelles fonctionnalités de langage?

Si j'ai un script Python qui nécessite au moins une version particulière de Python, quelle est la bonne façon d'échouer correctement lorsqu'une version antérieure de Python est utilisée pour lancer le script?

Comment obtenir le contrôle suffisamment tôt pour émettre un message d'erreur et quitter?

Par exemple, j'ai un programme qui utilise l'opérateur de ternerie (nouveau en 2.5) et des blocs "avec" (nouveau en 2.6). J'ai écrit une petite routine simple de vérificateur de version d'interpréteur qui est la première chose que le script appellerait ... sauf qu'il ne va pas aussi loin. Au lieu de cela, le script échoue pendant la compilation de python, avant même que mes routines soient appelées. Ainsi, l'utilisateur du script voit des traces d'erreurs de synchronisation très obscures - qui nécessitent à peu près un expert pour déduire qu'il s'agit simplement d'exécuter la mauvaise version de Python.

Je sais comment vérifier la version de Python. Le problème est qu'une syntaxe est illégale dans les anciennes versions de Python. Considérez ce programme:

import sys
if sys.version_info < (2, 4):
    raise "must use python 2.5 or greater"
else:
    # syntax error in 2.4, ok in 2.5
    x = 1 if True else 2
    print x

Lorsque exécuté sous 2.4, je veux ce résultat

$ ~/bin/python2.4 tern.py 
must use python 2.5 or greater

et non ce résultat:

$ ~/bin/python2.4 tern.py 
  File "tern.py", line 5
    x = 1 if True else 2
           ^
SyntaxError: invalid syntax

(Canalisation pour un collègue.)

Vous pouvez tester en utilisant eval:

try:
  eval("1 if True else 2")
except SyntaxError:
  # doesn't have ternary

Aussi, with est disponible en Python 2.5, il suffit d'ajouter from __future__ import with_statement.

EDIT: pour obtenir le contrôle suffisamment tôt, vous pouvez le diviser en différents .pyfichiers et vérifier la compatibilité dans le fichier principal avant l'importation (par exemple __init__.pydans un package):

# __init__.py

# Check compatibility
try:
  eval("1 if True else 2")
except SyntaxError:
  raise ImportError("requires ternary support")

# import from another module
from impl import *

Ayez un wrapper autour de votre programme qui fait ce qui suit.

import sys

req_version = (2,5)
cur_version = sys.version_info

if cur_version >= req_version:
   import myApp
   myApp.run()
else:
   print "Your Python interpreter is too old. Please consider upgrading."

Vous pouvez également envisager d'utiliser sys.version(), si vous prévoyez de rencontrer des personnes qui utilisent des interprètes Python antérieurs à 2.0, mais vous avez alors quelques expressions régulières à faire.

Et il pourrait y avoir des façons plus élégantes de le faire.

Essayer

plateforme d'importation
platform.python_version ()

Devrait vous donner une chaîne comme "2.3.1". Si ce n'est pas exactement ce que vous voulez, il existe un riche ensemble de données disponibles via le build-in "plateforme". Ce que vous voulez devrait être quelque part.

La meilleure façon de faire cette comparaison de versions est probablement d'utiliser le sys.hexversion. Ceci est important car la comparaison des tuples de version ne vous donnera pas le résultat souhaité dans toutes les versions de python.

import sys
if sys.hexversion < 0x02060000:
    print "yep!"
else:
    print "oops!"

import sys    
# prints whether python is version 3 or not
python_version = sys.version_info.major
if python_version == 3:
    print("is python 3")
else:
    print("not python 3")

Réponse de Nykakin à AskUbuntu :

Vous pouvez également vérifier la version Python à partir du code lui-même en utilisant le platformmodule de la bibliothèque standard.

Il y a deux fonctions:

• platform.python_version() (renvoie une chaîne).
• platform.python_version_tuple() (retourne un tuple).

Le code Python

Créez un fichier par exemple: version.py)

Méthode simple pour vérifier la version:

import platform

print(platform.python_version())
print(platform.python_version_tuple())

Vous pouvez également utiliser la evalméthode:

try:
  eval("1 if True else 2")
except SyntaxError:
  raise ImportError("requires ternary support")

Exécutez le fichier Python dans une ligne de commande:

$ python version.py 
2.7.11
('2', '7', '11')

La sortie de Python avec CGI via un serveur WAMP sous Windows 10:

Ressources utiles

• /ubuntu/505081/what-version-of-python-do-i-have

Les ensembles sont devenus une partie du langage de base de Python 2.4, afin de rester rétrocompatible. Je l'ai fait à l'époque, ce qui fonctionnera également pour vous:

if sys.version_info < (2, 4):
    from sets import Set as set

Bien que la question soit: comment obtenir le contrôle suffisamment tôt pour émettre un message d'erreur et quitter ?

La question à laquelle je réponds est: comment obtenir le contrôle suffisamment tôt pour émettre un message d'erreur avant de démarrer l'application ?

Je peux y répondre très différemment des autres articles. Il semble que les réponses tentent jusqu'à présent de résoudre votre question depuis Python.

Je dis, faites une vérification de version avant de lancer Python. Je vois que votre chemin est Linux ou unix. Cependant je ne peux que vous proposer un script Windows. Je pense que l'adapter à la syntaxe de script Linux ne serait pas trop difficile.

Voici le script DOS avec la version 2.7:

@ECHO OFF
REM see http://ss64.com/nt/for_f.html
FOR /F "tokens=1,2" %%G IN ('"python.exe -V 2>&1"') DO ECHO %%H | find "2.7" > Nul
IF NOT ErrorLevel 1 GOTO Python27
ECHO must use python2.7 or greater
GOTO EOF
:Python27
python.exe tern.py
GOTO EOF
:EOF

Cela n'exécute aucune partie de votre application et ne déclenchera donc pas d'exception Python. Il ne crée aucun fichier temporaire et n'ajoute aucune variable d'environnement OS. Et cela ne met pas votre application à une exception en raison de règles de syntaxe de version différentes. C'est trois points d'accès de sécurité moins possibles.

La FOR /Fligne est la clé.

FOR /F "tokens=1,2" %%G IN ('"python.exe -V 2>&1"') DO ECHO %%H | find "2.7" > Nul

Pour plusieurs versions de python, consultez l'url: http://www.fpschultze.de/modules/smartfaq/faq.php?faqid=17

Et ma version hack:

[Script MS; Vérification de la version Python avant le lancement du module Python] http://pastebin.com/aAuJ91FQ

import sys
sys.version

obtiendra une réponse comme celle-ci

'2.7.6 (par défaut, 26 octobre 2016, 20:30:19) \ n [GCC 4.8.4]'

ici 2.7.6 est la version

Comme indiqué ci-dessus, des erreurs de syntaxe se produisent au moment de la compilation et non au moment de l'exécution. Alors que Python est un "langage interprété", le code Python n'est pas réellement directement interprété; il est compilé en code octet, qui est ensuite interprété. Il y a une étape de compilation qui se produit lorsqu'un module est importé (s'il n'y a pas de version déjà compilée disponible sous la forme d'un fichier .pyc ou .pyd) et c'est là que vous obtenez votre erreur, pas (tout à fait exactement) quand votre code est en cours d'exécution.

Vous pouvez différer l'étape de compilation et la faire se produire au moment de l'exécution pour une seule ligne de code, si vous le souhaitez, en utilisant eval, comme indiqué ci-dessus, mais je préfère personnellement éviter de le faire, car cela fait que Python fonctionne potentiellement compilation inutile au moment de l'exécution, pour une chose et pour une autre, cela crée ce qui me semble être un encombrement de code. (Si vous le souhaitez, vous pouvez générer du code qui génère du code qui génère du code - et avoir un temps absolument fabuleux à modifier et à déboguer dans 6 mois.) Donc, je recommanderais plutôt quelque chose comme ceci:

import sys
if sys.hexversion < 0x02060000:
    from my_module_2_5 import thisFunc, thatFunc, theOtherFunc
else:
    from my_module import thisFunc, thatFunc, theOtherFunc

.. ce que je ferais même si je n'avais qu'une seule fonction qui utilisait une syntaxe plus récente et c'était très court. (En fait, je prendrais toutes les mesures raisonnables pour minimiser le nombre et la taille de ces fonctions. Je pourrais même écrire une fonction comme ifTrueAElseB (cond, a, b) avec cette seule ligne de syntaxe.)

Une autre chose qui mérite d'être soulignée (que je suis un peu étonné que personne n'ait encore souligné) est que, même si les versions antérieures de Python ne prenaient pas en charge le code comme

value = 'yes' if MyVarIsTrue else 'no'

..il a pris en charge le code comme

value = MyVarIsTrue and 'yes' or 'no'

C'était l'ancienne façon d'écrire des expressions ternaires. Je n'ai pas encore installé Python 3, mais pour autant que je sache, cette "ancienne" méthode fonctionne toujours à ce jour, vous pouvez donc décider vous-même si cela vaut la peine d'utiliser conditionnellement la nouvelle syntaxe, si vous avez besoin pour prendre en charge l'utilisation des anciennes versions de Python.

Mettez ce qui suit tout en haut de votre fichier:

import sys

if float(sys.version.split()[0][:3]) < 2.7:
    print "Python 2.7 or higher required to run this code, " + sys.version.split()[0] + " detected, exiting."
    exit(1)

Continuez ensuite avec le code Python normal:

import ...
import ...
other code...

Je pense que la meilleure façon est de tester les fonctionnalités plutôt que les versions. Dans certains cas, c'est trivial, pas dans d'autres.

par exemple:

try :
    # Do stuff
except : # Features weren't found.
    # Do stuff for older versions.

Tant que vous êtes suffisamment précis pour utiliser les blocs try / except, vous pouvez couvrir la plupart de vos bases.

Je viens de trouver cette question après une recherche rapide tout en essayant de résoudre le problème moi-même et j'ai trouvé un hybride basé sur quelques-unes des suggestions ci-dessus.

J'aime l'idée de DevPlayer d'utiliser un script d'encapsuleur, mais l'inconvénient est que vous finissez par maintenir plusieurs encapsuleurs pour différents systèmes d'exploitation, j'ai donc décidé d'écrire l'encapsuleur en python, mais utilisez la même logique de base "saisir la version en exécutant l'exe". et est venu avec cela.

Je pense que cela devrait fonctionner pour 2.5 et au-delà. Je l'ai testé sur 2.66, 2.7.0 et 3.1.2 sur Linux et 2.6.1 sur OS X jusqu'à présent.

import sys, subprocess
args = [sys.executable,"--version"]

output, error = subprocess.Popen(args ,stdout = subprocess.PIPE, stderr = subprocess.PIPE).communicate()
print("The version is: '%s'"  %error.decode(sys.stdout.encoding).strip("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLMNBVCXZ,.+ \n") )

Oui, je sais que la ligne finale de décodage / strip est horrible, mais je voulais juste saisir rapidement le numéro de version. Je vais affiner cela.

Cela fonctionne assez bien pour moi pour l'instant, mais si quelqu'un peut l'améliorer (ou me dire pourquoi c'est une terrible idée), ce serait cool aussi.

Pour les scripts python autonomes , l'astuce docstring de module suivante pour appliquer une version python (ici v2.7.x) fonctionne (testée sur * nix).

#!/bin/sh
''''python -V 2>&1 | grep -q 2.7 && exec python -u -- "$0" ${1+"$@"}; echo "python 2.7.x missing"; exit 1 # '''

import sys
[...]

Cela devrait également gérer l'exécutable python manquant mais a une dépendance sur grep. Voir ici pour le contexte.

Vous pouvez vérifier avec sys.hexversionou sys.version_info.

sys.hexversionn'est pas très convivial pour les humains car c'est un nombre hexadécimal. sys.version_infoest un tuple, il est donc plus convivial pour l'homme.

Vérifiez Python 3.6 ou plus récent avec sys.hexversion:

import sys, time
if sys.hexversion < 0x30600F0:
    print("You need Python 3.6 or greater.")
    for _ in range(1, 5): time.sleep(1)
    exit()

Vérifiez Python 3.6 ou plus récent avec sys.version_info:

import sys, time
if sys.version_info[0] < 3 and sys.version_info[1] < 6:
    print("You need Python 3.6 or greater.")
    for _ in range(1, 5): time.sleep(1)
    exit()

sys.version_infoest plus convivial pour l'homme, mais prend plus de personnages. Je recommanderais sys.hexversion, même si c'est moins convivial pour l'homme.

J'espère que cela vous a aidé!

Je développe l'excellente réponse d'Akhan, qui affiche un message utile avant même que le script Python ne soit compilé.

Si vous voulez vous assurer que le script est exécuté avec Python 3.6 ou plus récent, ajoutez ces deux lignes en haut de votre script Python:

#!/bin/sh
''''python3 -c 'import sys; sys.exit(sys.version_info < (3, 6))' && exec python3 -u -- "$0" ${1+"$@"}; echo 'This script requires Python 3.6 or newer.'; exit 1 # '''

(Remarque: la deuxième ligne commence par quatre guillemets simples et se termine par trois guillemets simples. Cela peut sembler étrange, mais ce n'est pas une faute de frappe.)

L'avantage de cette solution est que le code comme print(f'Hello, {name}!')ne causera pas de SyntaxErrorsi une version Python plus ancienne que 3.6 est utilisée. Vous verrez plutôt ce message utile:

This script requires Python 3.6 or newer.

Bien sûr, cette solution ne fonctionne que sur des shells de type Unix, et uniquement lorsque le script est appelé directement (tel que ./script.py:), et avec les bons bits d'autorisation eXecute définis.

Que dis-tu de ça:

import sys

def testPyVer(reqver):
  if float(sys.version[:3]) >= reqver:
    return 1
  else:
    return 0

#blah blah blah, more code

if testPyVer(3.0) == 1:
  #do stuff
else:
  #print python requirement, exit statement

Le problème est assez simple. Vous avez vérifié si la version était inférieure à 2,4, pas inférieure ou égale à . Donc, si la version Python est 2.4, elle n'est pas inférieure à 2.4. Vous auriez dû avoir:

    if sys.version_info **<=** (2, 4):

, ne pas

    if sys.version_info < (2, 4):