Comment puis-je vérifier quelle version de l'interpréteur Python interprète mon script?

Ces informations sont disponibles dans la chaîne sys.version du module sys :

>>> import sys

Lisible par l'homme:

>>> print(sys.version)  # parentheses necessary in python 3.       
2.5.2 (r252:60911, Jul 31 2008, 17:28:52) 
[GCC 4.2.3 (Ubuntu 4.2.3-2ubuntu7)]

Pour un traitement ultérieur:

>>> sys.version_info
(2, 5, 2, 'final', 0)
# or
>>> sys.hexversion
34014192

Pour vous assurer qu'un script s'exécute avec une version minimale requise de l'interpréteur Python, ajoutez ceci à votre code:

assert sys.version_info >= (2, 5)

Cela compare les informations de version majeure et mineure. Ajouter micro (= 0, 1etc.) et même releaselevel (= 'alpha', 'final'etc.) au tuple que vous aimez. Notez cependant qu'il est presque toujours préférable de vérifier "duck" si une certaine fonctionnalité est là, et sinon, une solution de contournement (ou renflouement). Parfois, les fonctionnalités disparaissent dans les nouvelles versions, remplacées par d'autres.

Depuis la ligne de commande (notez le «V» majuscule):

python -V

Ceci est documenté dans 'man python'.

J'aime sys.hexversionpour des trucs comme ça.

http://docs.python.org/library/sys.html#sys.hexversion

>>> import sys
>>> sys.hexversion
33883376
>>> '%x' % sys.hexversion
'20504f0'
>>> sys.hexversion < 0x02060000
True

Votre meilleur pari est probablement quelque chose comme ça:

>>> import sys
>>> sys.version_info
(2, 6, 4, 'final', 0)
>>> if not sys.version_info[:2] == (2, 6):
...    print "Error, I need python 2.6"
... else:
...    from my_module import twoPointSixCode
>>> 

De plus, vous pouvez toujours encapsuler vos importations dans un simple essai, ce qui devrait détecter les erreurs de syntaxe. Et, au point de @ Heikki, ce code sera compatible avec des versions beaucoup plus anciennes de python:

>>> try:
...     from my_module import twoPointSixCode
... except Exception: 
...     print "can't import, probably because your python is too old!"
>>>

Utilisez platform« spython_version du stdlib:

>>> from platform import python_version
>>> print(python_version())
2.7.8

Mettez quelque chose comme:

#!/usr/bin/env/python
import sys
if sys.version_info<(2,6,0):
  sys.stderr.write("You need python 2.6 or later to run this script\n")
  exit(1)

en haut de votre script.

Notez que selon ce qui se trouve dans votre script, les anciennes versions de python que la cible peuvent ne pas être en mesure de charger le script, donc n'iront pas assez loin pour signaler cette erreur. Comme solution de contournement, vous pouvez exécuter ce qui précède dans un script qui importe le script avec le code plus moderne.

Voici une version courte en ligne de commande qui se ferme immédiatement (pratique pour les scripts et l'exécution automatisée):

python -c "print(__import__('sys').version)"

Ou juste le majeur, le mineur et le micro:

python -c "print(__import__('sys').version_info[:1])" # (2,)
python -c "print(__import__('sys').version_info[:2])" # (2, 7)
python -c "print(__import__('sys').version_info[:3])" # (2, 7, 6)

Avec le sixmodule, vous pouvez le faire en:

import six

if six.PY2:
  # this is python2.x
else:
  # six.PY3
  # this is python3.x

import sys
sys.version.split(' ')[0]

sys.version vous donne ce que vous voulez, choisissez simplement le premier numéro :)

Comme l'a dit Seth, le script principal pourrait vérifier sys.version_info(mais notez que cela n'apparaissait pas avant 2.0, donc si vous voulez prendre en charge les anciennes versions, vous devrez vérifier une autre propriété de version du module sys).

Mais vous devez toujours vous assurer de ne pas utiliser de fonctionnalités de langage Python dans le fichier qui ne sont pas disponibles dans les anciennes versions de Python. Par exemple, cela est autorisé dans Python 2.5 et versions ultérieures:

try:
    pass
except:
    pass
finally:
    pass

mais ne fonctionnera pas dans les anciennes versions de Python, car vous ne pouviez avoir que OU enfin correspondre à l'essai. Donc, pour la compatibilité avec les anciennes versions de Python, vous devez écrire:

try:
    try:
        pass
    except:
        pass
finally:
    pass

La manière la plus simple

Tapez simplement python dans votre terminal et vous pouvez voir la version comme suit

desktop:~$ python
Python 2.7.6 (default, Jun 22 2015, 18:00:18) 
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 

Plusieurs réponses suggèrent déjà comment interroger la version actuelle de python. Pour vérifier par programme les exigences de version, j'utiliserais l'une des deux méthodes suivantes:

# Method 1: (see krawyoti's answer)
import sys
assert(sys.version_info >= (2,6))

# Method 2: 
import platform
from distutils.version import StrictVersion 
assert(StrictVersion(platform.python_version()) >= "2.6")

Juste pour le plaisir, ce qui suit est une façon de le faire sur CPython 1.0-3.7b2, Pypy, Jython et Micropython. C'est plus une curiosité qu'une façon de le faire dans le code moderne. Je l'ai écrit dans le cadre de http://stromberg.dnsalias.org/~strombrg/pythons/ , qui est un script pour tester un extrait de code sur de nombreuses versions de python à la fois, afin que vous puissiez facilement avoir une idée de ce que python les fonctionnalités sont compatibles avec quelles versions de python:

via_platform = 0
check_sys = 0
via_sys_version_info = 0
via_sys_version = 0
test_sys = 0
try:
    import platform
except (ImportError, NameError):
    # We have no platform module - try to get the info via the sys module
    check_sys = 1

if not check_sys:
    if hasattr(platform, "python_version"):
        via_platform = 1
    else:
        check_sys = 1

if check_sys:
    try:
        import sys
        test_sys = 1
    except (ImportError, NameError):
        # just let via_sys_version_info and via_sys_version remain False - we have no sys module
        pass

if test_sys:
    if hasattr(sys, "version_info"):
        via_sys_version_info = 1
    elif hasattr(sys, "version"):
        via_sys_version = 1
    else:
        # just let via_sys remain False
        pass

if via_platform:
    # This gives pretty good info, but is not available in older interpreters.  Also, micropython has a
    # platform module that does not really contain anything.
    print(platform.python_version())
elif via_sys_version_info:
    # This is compatible with some older interpreters, but does not give quite as much info.
    print("%s.%s.%s" % sys.version_info[:3])
elif via_sys_version:
    import string
    # This is compatible with some older interpreters, but does not give quite as much info.
    verbose_version = sys.version
    version_list = string.split(verbose_version)
    print(version_list[0])
else:
    print("unknown")

Si vous voulez détecter pré-Python 3 et ne voulez rien importer ...

... vous pouvez (ab) utiliser les changements de portée de compréhension de liste et le faire en une seule expression :

is_python_3_or_above = (lambda x: [x for x in [False]] and None or x)(True)

from sys import version_info, api_version, version, hexversion

print(f"sys.version: {version}")
print(f"sys.api_version: {api_version}")
print(f"sys.version_info: {version_info}")
print(f"sys.hexversion: {hexversion}")

production

sys.version: 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)]
sys.api_version: 1013
sys.version_info: sys.version_info(major=3, minor=6, micro=5, releaselevel='final', serial=0)
sys.hexversion: 50726384

Vérifiez la version Python: python -Vou python --versionouapt-cache policy python

vous pouvez également exécuter whereis pythonpour voir combien de versions sont installées.

sys.version_infone semble pas retourner un en tupledate de 3.7. Au contraire, il renvoie une classe spéciale, donc tous les exemples utilisant des tuples ne fonctionnent pas, du moins pour moi. Voici la sortie d'une console python:

>>> import sys
>>> type(sys.version_info)
<class 'sys.version_info'>

J'ai trouvé que l'utilisation d'une combinaison de sys.version_info.majoret sys.version_info.minorsemble suffire. Par exemple,...

import sys
if sys.version_info.major > 3:
    print('Upgrade to Python 3')
    exit(1)

vérifie si vous exécutez Python 3. Vous pouvez même rechercher des versions plus spécifiques avec ...

import sys
ver = sys.version_info
if ver.major > 2:
    if ver.major == 3 and ver.minor <= 4:
        print('Upgrade to Python 3.5')
        exit(1)

peut vérifier si vous utilisez au moins Python 3.5.

Pour vérifier la version Python des commandes sous Windows, exécutez les commandes suivantes dans une invite de commande et vérifiez la sortie

c:\>python -V
Python 2.7.16

c:\>py -2 -V
Python 2.7.16

c:\>py -3 -V
Python 3.7.3

De plus, pour voir la configuration des dossiers pour chaque version de Python, exécutez les commandes suivantes:

For Python 2,'py -2 -m site'
For Python 3,'py -3 -m site'

Si vous travaillez sur Linux, donnez simplement une python sortie de commande comme celle-ci

Python 2.4.3 (# 1, 11 juin 2009, 14:09:37)

[GCC 4.1.2 20080704 (Red Hat 4.1.2-44)] sur linux2

Tapez "aide", "copyright", "crédits" ou "licence" pour plus d'informations.

La manière la plus simple et la plus simple:

Dans Spyder, démarrez une nouvelle "console IPython", puis exécutez l'un de vos scripts existants.

Maintenant, la version peut être vue dans la première sortie imprimée dans la fenêtre de la console:

"Python 3.7.3 (par défaut, 24 avril 2019, 15:29:51) ..."

Pour vérifier à partir de la ligne de commande, en une seule commande, mais inclure la version majeure, mineure, micro, releaselevel et serial , puis appelez le même interpréteur Python (c'est-à-dire le même chemin) que celui que vous utilisez pour votre script:

> path/to/your/python -c "import sys; print('{}.{}.{}-{}-{}'.format(*sys.version_info))"

3.7.6-final-0

Remarque: .format()au lieu de f-strings ou '.'.join()vous permet d'utiliser des caractères de formatage et de séparateur arbitraires, par exemple pour en faire une chaîne d'un mot greppable. Je mets cela dans un script utilitaire bash qui rapporte toutes les versions importantes: python, numpy, pandas, sklearn, MacOS, xcode, clang, brew, conda, anaconda, gcc / g ++ etc. .