à Partir de la ligne de commande (notez la majuscule de "V"):

python -V

ceci est documenté dans 'man python'.

j'aime sys.hexversion pour 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:

>>> 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
>>> 

en outre, vous pouvez toujours envelopper vos importations dans un essai simple, qui devrait attraper des erreurs de syntaxe. Et, pour @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!"
>>>

Utiliser platform 's python_version de la stdlib:

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

Mettre 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 qu'il y a d'autre dans votre script, les versions plus anciennes de python que la cible peuvent ne pas être capables 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 sort immédiatement (pratique pour les scripts et l'exécution automatisée):

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

Ou tout simplement le majeur, mineur et 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)

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.
>>> 

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

sys.la version vous donne ce que vous voulez, il suffit de choisir le premier numéro :)

comme Seth l'a dit, le script principal pouvait cocher sys.version_info (mais notez que cela n'est apparu qu'en 2.0, donc si vous voulez prendre en charge des versions plus anciennes, vous devez vérifier une autre propriété de version du module sys).

mais vous devez toujours prendre soin de ne pas utiliser de fonctionnalités en langage Python dans le fichier qui ne sont pas disponibles dans les versions plus anciennes de Python. Par exemple, Ceci est autorisé en Python 2.5 et plus tard:

try:
    pass
except:
    pass
finally:
    pass

mais ne veut pas travailler dans des versions plus anciennes de Python, parce que vous ne pouviez avoir qu'à part ou finalement correspondre à l'essai. Donc pour la compatibilité avec les anciennes versions de Python vous devez écrire:

try:
    try:
        pass
    except:
        pass
finally:
    pass

avec six module, vous pouvez le faire par:

import six

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

vérifier la version Python: python -V ou python --version ou apt-cache policy python

vous pouvez aussi lancer whereis python pour voir combien de versions sont installées.

pour voir un script MSDOS pour vérifier la version avant d'exécuter L'interpréteur Python( pour éviter les exceptions à la syntaxe de la version Python) voir la solution:

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

et

MS script Python vérification de la version prelaunch de module Python http://pastebin.com/aAuJ91FQ (script probablement facile à convertir en Autres scripts OS.)

plusieurs réponses suggèrent déjà comment query la version actuelle de python. Pour vérifier programmatiquement les exigences de version, je ferais usage de 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 fun, voici un moyen de le faire sur Disponible 1.0-3.7b2, Pypy, Jython et Micropython. C'est plus une curiosité qu'une façon de le faire dans un code moderne. Je l'ai écrit dans le cadre de http://stromberg.dnsalias.org/~strombrg/pythons / , qui est un script pour tester un morceau de code sur plusieurs versions de python à la fois, de sorte que vous pouvez facilement avoir une idée de ce que les fonctionnalités de python 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 travaillez sur linux donnez juste la commande python la sortie sera comme ceci

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

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

Type "help", "copyright", "credits" ou "licence" pour plus d' information.

sys.version_info ne semble pas retourner un tuple à partir de 3.7. Il renvoie plutôt une classe spéciale, de sorte que tous les exemples d'utilisation de 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.major et sys.version_info.minor semble suffire. Exemple.,..

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

vérifie si vous utilisez Python 3. Vous pouvez même vérifier 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.